Program dijkstra;
type lista = ^celula;
     celula = record
              nod : longint;
              cost : longint;
              pred : lista;
               end;
const INF= 999999999;
var Lda : array [1..50000] of lista;
    r  :lista;
    H,D: array [1..50000] of longint;
    n,i,a,b,c,v,k,aux,p: longint;
 
procedure swap(var x,y : longint);
  var aux : longint;
    begin
       aux:=x;
       x:=y;
       y:=aux;
    end;
 
procedure coboara(k : longint);
  var fiu : longint;
    begin
         repeat
               fiu:=0;
               if k*2<n then
                  begin
                       fiu:=k*2;
                       if D[H[k*2+1]]<D[H[k*2]] then fiu:=k*2+1;
                       if D[H[fiu]]>=D[H[k]] then fiu:=0
                  end
                                  else  if k*2=n then
                                        begin
                                              fiu:=k*2;
                                              if D[H[fiu]]>=D[H[k]] then fiu:=0;
                                        end;
                  if fiu<>0 then begin
                                       swap(H[k],H[fiu]);
                                       k:=fiu;
                                 end;
         until fiu=0;
   end;
 
 
procedure ridica(k : longint);
   var aux,aux1 : longint;
     begin
       aux:=H[k];
       aux1:=D[H[k]];
       while (k>1) and (aux1<D[H[k div 2]]) do begin
                                                 H[k]:=H[k div 2];
                                                 k:=k div 2;
                                             end;
         D[H[k]]:=aux1;
         H[k]:=aux;
       end;
 
 
procedure sterge(var n : longint ; k : longint);
  begin
    H[k]:=H[n];
    n:=n-1;
 
    if ((k>1) and (D[k]<D[k div 2])) then ridica(k)
                                     else coboara(k);
end;
 
procedure add (v,c : longint; var p : lista);
  var r : lista;
     begin
        new(r);
        r^.nod:=v;
        r^.cost:=c;
        r^.pred:=p;
        p:=r;
     end;
begin
   assign(input,'dijkstra.in'); reset(input);
   assign(output,'dijkstra.out'); rewrite(output);
   readln(n,p); aux:=n;
   for i:=1 to p do begin
                        readln(a,b,c);
                        {add(a,c,lda[b]);}
                        add(b,c,lda[a]);
                    end;
 
   for i:=2 to n do D[i]:=INF;
   for i:=1 to n do H[i]:=i;
   while n>0 do begin
                     v:=H[1];
                     r:=lda[v];
                     sterge(n,1);
   while r<>nil do begin
                         if (r^.cost<>0) then
                            if D[v]+r^.cost<D[r^.nod] then
                                                  begin
                                                     D[r^.nod]:=D[v]+r^.cost;
                                                     for k:=1 to n do coboara(k);
                                                  end;
                         r:=r^.pred;
                    end;
 
                   end;
   for i:=2 to aux do 
                   if D[i]=INF then write(0,' ')
                               else write(D[i],' ');
   close(input);
   close(output);
end.