#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];
int poz [Nmax], h [Nmax] , d [Nmax];
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;

    while ( p <= k )
    {
        i = p;

        if ( i * 2 <= k )
        {
            i *= 2;

            if ( i+1 <=k )
                if ( d[ h[i+1]] < d[h[i]] )
                    i++;
        }

        else
            return;

        if ( d[ h[i] ] < d[ h[p] ] )
        {
            poz [ h[i] ] = p;

            poz [ h[p] ] = i;

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

            p = i;
        }

        else
            return;
    }
}

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

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

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

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

            i = tata;
        }

        else
            return ;
    }
}

int extrag_min ( )
{
    int minim = h[1];
    swap ( h[1], h[k] );
    poz[ h[1] ] = 1;
    k--;
    downheap( 1 );

    return minim;
}

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

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

    h[ ++k ] = 1;
    d[1] = 0;
    poz[1] = 1;

    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 ( 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;


    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);
    }
}