// folosim o coada in care initial punem elementul de pornire ( start )
// la fiecare pas adaugam vecinii si updatam
// de fiecare data scoatem elementul din fata din coada
// si dupa ii adaugam vecinii
// avem grija sa mentinem cel mai bun cost pentru fiecare
// complexitatea se imbunatateste datorita faptului ca daca un element e in coada nu il mai imbunatatesc
// cand vom ajunge la costurile minime coada se goleste de la sine
// daca am trecut de mai mult de N ori printr-un element este clar ca avem un ciclu cu cost mai mic decat 0 deci ne oprim

#include <fstream>
#include <vector>
#include <queue>
using namespace std;

#define Nmax 50011
#define Mmax 250011

#define val first
#define key second

#define oo 1<<30

vector< pair<int,int> > A[Nmax];
vector< pair<int,int> > Aux;
queue< int > Q;
int Cost[Nmax],N,M;
bool Used[Nmax];
int Times[Nmax];

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

int main()
{
	F>>N>>M;
	for (int i=1;i<=M;++i)
	{
		int a,b,c;
		F>>a>>b>>c;
		A[a].push_back( make_pair( c , b ) );
	}
	for (int i=1;i<=N;++i)
		Cost[i]=oo;
	
	int Start=1;
	Cost[Start]=0;
	Q.push( Start );
	Used[Start]=1;
	
	while ( Q.size() )
	{
		int Nbr=Q.front();
		Q.pop();
		Used[Nbr]=0;
		
		while ( A[Nbr].size() )
		{
			Aux.push_back( A[Nbr].back() );
			A[Nbr].pop_back();
			
			if ( Cost[Aux.back().key] > Cost[Nbr] + Aux.back().val )
			{
				Cost[Aux.back().key] = Cost[Nbr] + Aux.back().val ;
				
				if ( !Used[ Aux.back().key ] )
				{
					Q.push( Aux.back().key );
					Used[ Aux.back().key ]=1;
					
					if ( ++Times[ Aux.back().key ] > N )
					{
						G<<"Ciclu negativ!\n";
						return 0;
					}
				}
			}
		}
		
		while ( Aux.size() )
		{
			A[Nbr].push_back( Aux.back() );
			Aux.pop_back();
		}
	}
	
	for (int i=2;i<=N;++i)
		G<<(Cost[i]==oo ? 0 : Cost[i])<<' ';
	G<<'\n';
}