/* Dijkstra algorithm for shortest path */
/*        with adjacency matrix         */

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

/* namespace std */
using std::vector;
using std::cout;
using std::cin;
using std::ifstream;
using std::ofstream;
using std::endl;

/* Streams */
ifstream fin("dijkstra.in");
ofstream fout("dijkstra.out");

/* Global_Variables */
int n,m,u,v,tempCost;
vector <vector<int> > edges_cost;
vector <int> distances;
vector <bool> visited;
const int ourMax=1001;

void ReadAndInitialize()
{
    int i;
    fin >> n >> m;
    edges_cost.resize(n);
    distances.resize(n,ourMax);
    visited.resize(n,false);
    for(i=0;i<n;i++) edges_cost[i].resize(n,ourMax);
    for(i=0;i<m;i++)
    {
        fin >> u >> v >> tempCost;
        u--; v--;
        edges_cost[u][v]=tempCost;
        edges_cost[v][u]=tempCost;
    }

}

void printDistances(int fromVertex)
{
    for(int i=0;i<n;i++)
    {
        if(fromVertex==i) continue;
        if(distances[i]<ourMax) fout << distances[i] << " ";
                else fout  << "0 ";
    }
}

void dijkstra(int vertex)
{
    int i,j;

    for(i=0;i<n;i++) distances[i]=ourMax;
    distances[vertex]=0;

    int current_node;

    for(i=0;i<n;i++)
    {
        current_node=-1;
        for(j=0;j<n;j++)
            if(!visited[j])
                if(current_node==-1 || distances[j]<distances[current_node]) current_node=j;

        visited[current_node]=true;
        for(j=0;j<n;j++)
        {
            tempCost = distances[current_node] + edges_cost[current_node][j];
            if(tempCost<distances[j]) distances[j]=tempCost;
        }
    }
}

int main()
{
    ReadAndInitialize();
    dijkstra(0);
    printDistances(0);
    return 0;
}