#include <iostream>
#include <fstream>
#include <vector>

using namespace std;

const long Infinit=2000000005;
vector <long> G[50005], C[50005];
long D[50005], Heap[50005], P[50005], NH;
unsigned long N;

void Read ()
{
    ifstream fin ("dijkstra.in");
    long M, i, X, Y, Z;
    fin >> N >> M;
    for (i=0; i<M; i++)
    {
        fin >> X >> Y >> Z;
        G[X].push_back (Y);
        C[X].push_back (Z);
    }
    fin.close ();
}

void Type ()
{
    ofstream fout ("dijkstra.out");
    unsigned long i;
    for (i=2; i<=N; i++)
    {
        if (D[i]==Infinit)
        {
            D[i]=0;
        }
        fout << D[i] << " ";
    }
    fout << "\n";
    fout.close ();
}

void Swap (long X, long Y)
{
    long Aux;
    Aux=P[Heap[X]];
    P[Heap[X]]=P[Heap[Y]];
    P[Heap[Y]]=Aux;
    Aux=Heap[X];
    Heap[X]=Heap[Y];
    Heap[Y]=Aux;
}

void Sift (long X)
{
    long S=X;
    if (2*X<=NH)
    {
        S=2*X;
    }
    if ((2*X+1<=NH)&&(D[Heap[S]]>D[Heap[2*X+1]]))
    {
        S++;
    }
    if (D[Heap[S]]<D[Heap[X]])
    {
        Swap (X, S);
        Sift (S);
    }
}

void Percolate (long X)
{
    long F=X/2;
    if ((D[Heap[F]]>D[Heap[X]])&&(F>0))
    {
        Swap (X, F);
        Percolate (F);
    }
}

void Insert (long X)
{
    Heap[++NH]=X;
    P[Heap[NH]]=NH;
    Percolate (NH);
}

void Delete (long X)
{
    Heap[X]=Heap[NH--];
    P[Heap[X]]=1;
    Sift (X);
}

void Dijkstra (long Start)
{
    vector <long> :: iterator itg, itc;
    long NCurent;
    memset (D, Infinit, sizeof (D));
    memset (P, -1, sizeof (P));
    D[Start]=0;
    P[Start]=1;
    Heap[++NH]=Start;
    while (NH>0)
    {
        NCurent=Heap[1];
        Delete (1);
        for (itg=G[NCurent].begin (), itc=C[NCurent].begin (); itg!=G[NCurent].end (); itg++, itc++)
        {
            if (P[(*itg)]==-1)
            {
                D[(*itg)]=D[NCurent]+(*itc);
                Insert (*itg);
            }
            if (D[(*itg)]>D[NCurent]+(*itc))
            {
                D[(*itg)]=D[NCurent]+(*itc);
                Percolate (P[(*itg)]);
            }
        }
    }
}

int main()
{
    Read ();
    Dijkstra (1);
    Type ();
    return 0;
}