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

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

class graf {
    int nrN;
    int nrM;
    vector<vector<int>> matriceAd;

public:
    graf(int n, int m, vector<vector<int>> &mat) {
        nrN = n;
        nrM = m;
        matriceAd = mat;
    }

    graf(int n, int m) {
        nrN = n;
        nrM = m;
    }

    void citire_neorientat() {
        for (int i = 0; i < nrM; ++i) {
            int x, y;
            fin >> x >> y;
            matriceAd[x].push_back(y);
            matriceAd[y].push_back(x);
        }
    }

    void citire_orientat() {
        for (int i = 0; i < nrM; ++i) {
            int x, y;
            fin >> x >> y;
            matriceAd[x].push_back(y);
        }
    }

    void citire_sortaret(vector<int> &dep){
        for (int i = 0; i < nrM; ++i) {
            int x, y;
            fin>>x>>y;
            matriceAd[x].push_back(y);
            dep[y]++;
        }
    }

    void citire_dijkstra(vector<vector<int>>& mat){
        int a, b, c;
        for (int i = 0; i < nrM; ++i) {
            fin>>a>>b>>c;
            mat[a][b] = c;
        }
    }

    void BFS(int S) {
        queue<int> coada;
        int x, y;
        vector<int> cost(nrN + 1, -1);
        cost[S] = 0;
        coada.push(S);
        while (!coada.empty()) {
            x = coada.front();
            coada.pop();
            for (int i = 0; i < matriceAd[x].size(); ++i) {
                if (cost[matriceAd[x][i]] == -1) {
                    cost[matriceAd[x][i]] = cost[x] + 1;
                    coada.push(matriceAd[x][i]);
                }
            }
        }
        for (int i = 1; i < nrN + 1; i++)
            fout << cost[i] << " ";
    }

    void DFS() {
        queue<int> coada;
        vector<int> viz(nrN + 1, 0);
        int conex = 0;
        for (int i = 1; i <= nrN; ++i) {
            if (viz[i] == 0) {
                conex++;
                coada.push(i);
                while (!coada.empty()) {
                    int x = coada.front();
                    viz[x]++;
                    coada.pop();
                    for (int j = 1; j < matriceAd[x].size(); ++j) {
                        if (viz[matriceAd[x][j]] == 0)
                            coada.push(matriceAd[x][j]);
                    }
                }
            }
        }
        fout << conex;
    }

    void sortaret(vector<int> &dep){
        queue<int> coada;
        vector<int> sortare;
        for (int i = 1; i < nrN + 1; ++i) {
            if (dep[i] == 0)
                coada.push(i);
        }
        while (!coada.empty()){
            int x = coada.front();
            sortare.push_back(x);
            coada.pop();
            for (int i = 1; i < matriceAd[x].size(); ++i) {
                dep[matriceAd[x][i]]--;
                if (dep[matriceAd[x][i]] == 0)
                    coada.push(matriceAd[x][i]);
            }
        }
        for (int i = 0; i < nrN; ++i) {
            fout<<sortare[i]<<" ";
        }
    }

    int reprez(int& x, vector<int> tata){
        while (tata[x] != 0)
            x = tata[x];
        return x;
    }

    void op1(vector<int>& tata, vector<int>& h, int x, int y){
        int a = reprez(x, tata), b = reprez(y, tata);
        if (h[a] > h[b])
            tata[b] = a;
        else {
            tata[a] = b;
            if (h[a] == h[b])
                h[b]++;
        }
    }

    void op2(int x, int y, vector<int> tata){
        if (x == y)
            fout<<"DA"<<endl;
        else
            fout<<"NU"<<endl;
    }

    void solveDisjoint(){
        vector<int> tata(nrN + 1, 0), h(nrN + 1, 0);
        int op, x, y;
        for (int i = 0; i < nrM; ++i) {
            fin>>op>>x>>y;
            if (op == 1)
                op1(tata, h, x, y);
            else
                op2(reprez(x, tata), reprez(y, tata), tata);
        }
    }

    int minDist(vector<int>& dist, vector<bool>& SP){
        int min = INT_MAX, j;
        for (int i = 0; i < nrN; ++i) {
            if (!SP[i] && dist[i] <= min) {
                min = dist[i];
                j = i;
            }
        }
        return j;
    }

    void dijkstra(vector<vector<int>>& mat, int s){
        vector<int> dist (nrN + 1, INT_MAX);
        vector<bool> shortestPath (nrN + 1, false);
        dist[s] = 0;
        for (int i = 0; i < nrN - 1; ++i) {
            int u = minDist(dist, shortestPath);
            cout<<u;
            shortestPath[u] = true;
            for (int j = 1; j <= nrN; ++j) {
                if (!shortestPath[j] && mat[u][j] && dist[u] != INT_MAX && dist[u] + mat[u][j] < dist[j])
                    dist[j] = dist[u] + mat[u][j];
            }
        }
        for (int i = 2; i <= nrN; ++i) {
            fout<<dist[i]<<' ';
        }
    }
};
///BFS
//int main(){
//    int n, m, S;
//    fin >> n >> m >> S;
//    vector<vector<int>> mat;
//    vector<int> aux(1,-1);
//    mat.resize(n+1, aux);
//    graf G(n, m, mat);
//    G.citire_orientat();
//    G.BFS(S);
//    return 0;
//}

///DFS
//int main(){
//    int n, m;
//    fin>>n>>m;
//    vector<vector<int>> mat;
//    vector<int> aux(1,-1);
//    mat.resize(n+1, aux);
//    graf G(n, m, mat);
//    G.citire_neorientat();
//    G.DFS();
//    return 0;
//}

///sortaret
//int main(){
//    int n, m;
//    fin>>n>>m;
//    vector<int> dep(n + 1, 0);
//    vector<vector<int>> mat;
//    vector<int> aux(1,-1);
//    mat.resize(n+1, aux);
//    graf G(n, m, mat);
//    G.citire_sortaret(dep);
//    G.sortaret(dep);
//    return 0;
//}

///disjoint
//int main(){
//    int n, m;
//    fin>>n>>m;
//    graf G(n , m);
//    G.solveDisjoint();
//    return 0;
//}

///dijkstra
int main(){
    int n, m;
    fin>>n>>m;
    graf G(n, m);
    vector<vector<int>> matAd;
    vector<int> sec(n + 1, 0);
    matAd.resize(n + 1, sec);
    G.citire_dijkstra(matAd);
    G.dijkstra(matAd, 1);
    return 0;
}