#include<fstream>
#include<vector>

using namespace std;

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

int n, m, k, Heap_Size;
vector < pair <int, int> > G[50000];
int Fort[50000], Sol[50000], D[50000], A[50000], Heap[50000];
int const oo = 1000000000;

void citire()
{
    int i, x, y, c;
    f>>n>>m;//>>k;
    Heap_Size = n;

 //   for(i=1; i<=k; i++)
   //     f>>Fort[i];

    for(i=1; i<=m; i++){
        f>>x>>y>>c;
        G[x].push_back(make_pair(y, c));
        G[y].push_back(make_pair(x, c));
    }
}

void Swap(int x, int y)
{
    swap(A[Heap[x]], A[Heap[y]]);
    swap(Heap[x], Heap[y]);
}

void UpHeap(int pos)
{
    int TT = pos/2;
    if(TT && D[Heap[TT]] > D[Heap[pos]]){
        Swap(TT, pos);
        UpHeap(TT);
    }
}

void DownHeap(int pos)
{
    int son = 2*pos;
    if(son + 1 <= Heap_Size && D[Heap[son]] > D[Heap[son+1]])
        son++;
    if(son <= Heap_Size && D[Heap[son]] < D[Heap[pos]]){
        Swap(son, pos);
        DownHeap(son);
    }
}

void Dijkstra()
{
    int i, o, nod, vecin, cost;

    for(i=1; i<=n; i++){
        D[i] = oo;
        A[i] = i;
        Heap[i] = i;
    }

    D[1] = 0;

  /*  for(i=1; i<=k; i++){
        D[Fort[i]] = 0;
        Sol[Fort[i]] = Fort[i];
        UpHeap(A[Fort[i]]);
    }
*/
    for(o=1; o<=n; o++)
    {
        nod = Heap[1];
        Swap(1, Heap_Size--);
        DownHeap(1);

        for(i=0; i<G[nod].size(); i++){
            vecin = G[nod][i].first;
            cost = G[nod][i].second;
            if(D[nod] + cost < D[vecin]){
                D[vecin]  = D[nod] + cost;
              //  Sol[vecin] = Sol[nod];
                UpHeap(A[vecin]);
            }
        }
    }
}

void afisare()
{
/*    for(int i=1; i<=n; i++)
        if(Sol[i] == i)
            Sol[i] = 0;
*/
    for(int i=2; i<=n; i++)
        g<<D[i]<<" ";
    g<<"\n";
}

int main()
{
    citire();
    Dijkstra();
    afisare();
}