#include <fstream>
#include <vector>
#include <algorithm>
#include <cstring>

#define NMAX 50005
#define INF (1<<30)
#define pb push_back
#define mp make_pair
#define nod first
#define cost second

using namespace std;

ifstream in("dijkstra.in");
ofstream out("dijkstra.out");

int N, M, H[NMAX], Poz[NMAX], D[NMAX], i, x, y, c, Nr, NodMin;
vector< pair< int, int > > G[NMAX];
vector< pair< int, int > >::iterator it;

inline void Swap( int a, int b )
{
    int aux = H[a];
    H[a] = H[b];
    H[b] = aux;

    Poz[ H[a] ] = a;
    Poz[ H[b] ] = b;
}

inline void HeapDown( int NOD )
{
    if( 2*NOD <= Nr )
    {
        int Fiu = 2*NOD;
		
        if( 2*NOD + 1 <= Nr && D[ H[2*NOD+1] ] < D[ H[2*NOD] ] )
            ++Fiu;
		
        if( D[ H[Fiu] ] < D[ H[NOD] ] )
        {
            Swap( NOD, Fiu );
            HeapDown( Fiu );
        }
    }
}

inline void HeapUp( int NOD )
{
    if( NOD <= 1 ) return;

    int T = NOD/2;
    if( D[ H[T] ] > D[ H[NOD] ] )
    {
        Swap( T, NOD );
        HeapUp( T );
    }
}

inline void BuildHeap()
{
    for( int ii = 2 ; ii <= N; ii++ )
        HeapUp( ii );
}

inline void Scoate( int &minim )
{
    minim = H[1];
    Swap( 1, Nr-- );
    HeapDown( 1 );
}

int main()
{
    in >> N >> M;
    while( M-- )
    {
        in >> x >> y >> c;
        G[x].pb( mp( y, c ) );
    }
	
    for( i = 1; i <= N; i++ )
	{
        H[i] = Poz[i] = i;
		D[i] = INF;
	}

    D[1] = 0;
    Nr = N;
    BuildHeap();

    while( Nr )
    {
        Scoate( NodMin );
        for( it = G[NodMin].begin(); it != G[NodMin].end(); it++ )
            if( D[ (*it).nod ] > D[NodMin] + (*it).cost )
            {
                D[ (*it).nod ] = D[NodMin] + (*it).cost;
                HeapUp( Poz[ (*it).nod ] );
            }
    }

    for( i = 2; i <= N; i++ )
        ( D[i] != INF ) ? out << D[i] << ' ' : out << "0 ";
    out << '\n';

    return 0;
}