#include <bits/stdc++.h>
#define Nmax 50005
#define INF (1<<30)
using namespace std;

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

struct graf
{
    int node, cost;
};

vector < graf > v[Nmax];
vector < int > poz, h, d;
bitset < Nmax > b;

int n, m, k;

void Read ( );
void Dijkstra ( );

int main()
{
    Read ( );

    Dijkstra ( );

    for ( int i = 2; i <= n; i++ )
        fout << d[i] << ' ';

    return 0;
}

void downheap ( int p )
{
    int i = p;

    while ( i <= k )
    {
        if ( i * 2 <= k )
        {
            if ( d [ h[i] ] > d[ h[i*2] ] )
            {
                swap ( poz[ h[i] ], poz[ h[ i*2 ] ] );
                swap ( h[i], h[i*2] );

                i*=2;
            }
            else if ( i * 2 + 1 <= k )
                if ( d [h[i]] > d[ h[ i*2 + 1 ] ])
                {
                    swap ( poz[ h[i] ], poz[h[ i*2 + 1]] );
                    swap ( h[i], h[ i*2 + 1] );
                    i = i*2 + 1;
                }
                else
                    return;
            else
                return;
        }

        else
            return;
    }

    return;
}

void upheap ( int p )
{
    int i = p, tata;

    while ( i > 1 )
    {
        tata = i/2;

        if ( d [h[i]] < d[h[tata]] )
        {
            swap ( poz[h[i]], poz[h[tata]] );

            swap ( h[i], h[tata] );

            i = tata;
        }

        else return ;
    }
}

int extrag_min ( )
{
    int minim = h[1];
    k--;

    if ( k == 0 )
        return minim;

    poz[minim] = -1;
    h[1] = h[k + 1];
    poz[k] = 1;

    downheap( poz[k] );

    return minim;
}

void Dijkstra ( )
{
    int minim, lng, node;

    for ( int i = 1; i <= n; i++ )
        d[i] = INF, poz[i] = -1;

    h[ ++k ] = 1;

    poz[1] = 1;
    d[1] = 0;

    while ( k )
    {
        minim = extrag_min ( );

        lng = v[minim].size();

        b[minim] = 1;

        for ( int i = 0; i < lng; i++ )
        {
            node = v[minim][i].node;

            if ( b[node] == 0 )
            if ( d[node] > d[minim] + v[minim][i].cost )
                {
                    d[node] = d[minim] + v[minim][i].cost;

                    if ( poz[node] != -1 )
                        upheap ( poz[node] );

                    else
                    {
                        k++;
                        poz[node] = k;
                        h[k] = node;
                        upheap ( k );
                    }
                }
        }

    }
}

void Read ( )
{
    fin >> n >> m;

    poz.reserve ( n + 2);
    h.reserve ( n + 2);
    d.reserve ( n + 2);

    int x, y;
    graf aux;

    for ( int i = 1; i <= m; i++ )
    {
        fin >> x >> y >> aux.cost;

        aux.node = y;

        v[x].push_back(aux);

        aux.node = x;

        v[y].push_back(aux);
    }
}