#include <fstream>
#include <vector>
#define INF 0x3f3f3f3f
#define nodv g[nod][i].second
#define valv g[nod][i].first
using namespace std;

ifstream is("dijkstra.in");
ofstream os("dijkstra.out");

class Heap{
public:
    Heap(int siz) : nH(0), P(siz + 1)
    {
        H.push_back(0);
        C.push_back(0);
    }
    bool size()
    {
        return nH;
    }
    bool inH(int nod, int val)
    {
        if ( !P[nod] )
            return false;
        C[P[nod]] = val;
        up(val, nod);
        return true;
    }
    pair<int, int> top()
    {
        return make_pair(C[1], H[1]);
    }
    void push(int val, int nod)
    {
        H.push_back(nod);
        C.push_back(val);
        ++nH;
        P[nod] = nH;
        up(val, nod);
    }
    void up(int val, int nod)
    {
        int up = P[nod] / 2, down = P[nod];
        while ( up && C[down] < C[up] )
        {
            Swap(up, down);
            up /= 2;
            down /= 2;
        }
    }
    void pop()
    {
        P[H[1]] = 0;
        H[1] = H[nH];
        C[1] = C[nH--];
        H.pop_back();
        C.pop_back();
        int up = 1, down = 2;
        while ( ( down <= nH && C[down] < C[up] ) || ( down < nH && C[down + 1] < C[up] ) )
        {
            if ( down < nH && C[down] > C[down + 1] )
                ++down;
            Swap(down, up);
            up = down;
            down *= 2;
        }
    }
    void Swap(int n1, int n2)
    {
        swap(H[n1], H[n2]);
        swap(C[n1], C[n2]);
        swap(P[H[n1]], P[H[n2]]);
    }
private:
    int nH;
    vector<int> H, C, P;
};

int n, m;
vector<int> d;
vector<vector<pair<int, int> > > g;

void Read();
void Solve();
void Write();

int main()
{
    Read();
    Solve();
    Write();
    is.close();
    os.close();
    return 0;
}

void Solve()
{
    Heap hp(n + 1);
    pair<int, int> q;
    int nod, val;
    hp.push(0, 1);
    while ( hp.size() )
    {
        q = hp.top();
        val = q.first;
        nod = q.second;
        hp.pop();
        for ( size_t i = 0; i < g[nod].size(); ++i )
            if ( d[nodv] > d[nod] + valv )
            {
                d[nodv] = d[nod] + valv;
                if ( !hp.inH(nodv, d[nodv]) )
                    hp.push(d[nodv], nodv);
            }
    }
}

void Read()
{
    is >> n >> m;
    d = vector<int>(n + 1, INF);
    d[1] = 0;
    g = vector<vector<pair<int, int> > >(n + 1);
    int n1, n2, c;
    while ( m-- )
    {
        is >> n1 >> n2 >> c;
        g[n1].push_back(make_pair(c, n2));
    }
}

void Write()
{
    for ( int i = 2; i <= n; ++i )
        if ( d[i] == INF )
            os << "0 ";
        else
            os << d[i] << " ";
}