#include <queue>

 #include <vector>

 #include <cstdio>

 #include <cstring>

 #include <algorithm>

 #define N1 1010

 #define M1 2010

 #define S1 (N1<<1)

 #define T1 (N1<<2)

 #define ll long long

 #define uint unsigned int

 #define rint register int

 #define dd double

 #define il inline

 #define inf 233333333

 using namespace std;

 int gint()

 {

     int ret=,fh=;char c=getchar();

     while(c<''||c>''){if(c=='-')fh=-;c=getchar();}

     while(c>=''&&c<=''){ret=ret*+c-'';c=getchar();}

     return ret*fh;

 }

 int n,m;

 struct Edge{

 int to[M1*],nxt[M1*],val[M1*],head[N1],cte;

 void ae(int u,int v,int w)

 {cte++,to[cte]=v,nxt[cte]=head[u],val[cte]=w,head[u]=cte;}

 }E,T;

 struct SEG{

 int mi[T1];

 void pushdown(int rt)

 {

     mi[rt<<]=min(mi[rt<<],mi[rt]);

     mi[rt<<|]=min(mi[rt<<|],mi[rt]);

 }

 void build(int l,int r,int rt)

 {

     mi[rt]=inf;

     if(l==r) return;

     int mid=(l+r)>>;

     build(l,mid,rt<<);

     build(mid+,r,rt<<|);

 }

 void update(int L,int R,int l,int r,int rt,int w)

 {

     if(L<=l&&r<=R) {mi[rt]=min(mi[rt],w);return;}

     int mid=(l+r)>>; pushdown(rt);

     if(L<=mid) update(L,R,l,mid,rt<<,w);

     if(R>mid) update(L,R,mid+,r,rt<<|,w);

 }

 int query(int x,int l,int r,int rt)

 {

     if(l==r) return mi[rt];

     int mid=(l+r)>>; pushdown(rt);

     if(x<=mid) return query(x,l,mid,rt<<);

     else return query(x,mid+,r,rt<<|);

 }

 }s;

 int dis[N1],use[N1],fa[N1],la[N1],ist[M1*];

 struct node{

     int id,d;

     friend bool operator < (const node &s1,const node &s2)

     {return s1.d>s2.d;}

 };

 void dijkstra()

 {

     int j,v,u;

     memset(dis,0x3f,sizeof(dis));

     priority_queue<node>q;

     dis[]=,q.push((node){,});

     while(!q.empty())

     {

         node k=q.top(); q.pop(); u=k.id;

         if(use[u]) continue; use[u]=;

         for(j=E.head[u];j;j=E.nxt[j]){

             v=E.to[j];

             if(dis[v]>dis[u]+E.val[j])

                 dis[v]=dis[u]+E.val[j],q.push((node){v,dis[v]}),fa[v]=u,la[v]=j;

         }

     }

 }

 int dep[N1],sz[N1],tp[N1],son[N1],st[N1],id[N1],tot;

 void dfs1(int u,int dad)

 {

     for(int j=T.head[u];j;j=T.nxt[j])

     {

         int v=T.to[j]; if(v==dad) continue;

         dep[v]=dep[u]+; dfs1(v,u); //fa[v]=u;

         sz[u]+=sz[v]; son[u]=sz[v]>sz[son[u]]?v:son[u];

     }

     sz[u]++;

 }

 void dfs2(int u)

 {

     st[u]=++tot,id[tot]=u;

     if(son[u]) tp[son[u]]=tp[u],dfs2(son[u]);

     for(int j=T.head[u];j;j=T.nxt[j])

     {

         int v=T.to[j];

         if(v==son[u]||v==fa[u]) continue;

         tp[v]=v; dfs2(v);

     }

 }

 void update(int x,int y,int w)

 {

     int px=x,py=y;

     while(tp[x]!=tp[y])

     {

         if(dep[tp[x]]<dep[tp[y]]) swap(x,y);

         s.update(st[tp[x]],st[x],,n,,dis[px]+dis[py]+w);

         x=fa[tp[x]];

     }

     if(dep[x]>dep[y]) swap(x,y);

     if(x!=y) s.update(st[x]+,st[y],,n,,dis[px]+dis[py]+w);

 }

 void solve()

 {

     int x,y,i,j,v,ans; dijkstra(); s.build(,n,);

     for(i=;i<=n;i++) T.ae(fa[i],i,E.val[la[i]]),ist[la[i]]=;

     dep[]=,dfs1(,-); tp[]=,dfs2();

     for(j=;j<=m*;j+=)

     {

         if(ist[j]||ist[j+]) continue;

         x=E.to[j],y=E.to[j+];

         update(x,y,E.val[j]);

     }

     for(i=;i<=n;i++)

     {

         ans=s.query(st[i],,n,);

         if(ans==inf) printf("-1\n");

         else printf("%d\n",ans-dis[i]);

     }

 }

 int main()

 {

     scanf("%d%d",&n,&m);

     int i,j,x,y,z;E.cte=;

     for(i=;i<=m;i++) x=gint(),y=gint(),z=gint(),E.ae(x,y,z),E.ae(y,x,z);

     solve();

     return ;

 }