#include <fstream>
#include <vector>
#include <algorithm>
#include <queue>

using namespace std;
using PII = pair<int, int>;

ifstream f("dijkstra.in");
ofstream g("dijkstra.out");

static constexpr int nMAX = ((int)(5e4) + 1),
                     INF = ((int)(1e9));

int n;
vector<PII> G[nMAX];

int d[nMAX];
bool used[nMAX];

auto cmp = [](const PII x, const PII y)
{
    if (!(x.first < y.first))
        return 1;
    return 0;
};
priority_queue<PII, vector<PII>, decltype(cmp)> H(cmp);

static inline void read()
{
    f.tie(nullptr);

    int m = 0;
    f >> n >> m;

    int u = 0, v = 0, t = 0;
    for (int e = 1; e <= m; ++e)
        f >> u >> v >> t,
            G[u].push_back({t, v});

    return;
}

int main()
{
    read();

    for (int i = 1; i <= n; ++i)
        if ((int)G[i].size() > 1)
            sort(G[i].begin(), G[i].end());

    for (int i = 2; i <= n; ++i)
        d[i] = INF, used[i] = false;
    for (const PII &e : G[1])
        if (e.first < d[e.second])
            d[e.second] = e.first, H.push(e);
    d[1] = 0, used[1] = true;

    while (!H.empty())
    {
        while (!H.empty() && used[H.top().second])
            H.pop();
        if (H.empty())
            break;

        int min_Node = H.top().second,
            min_dist = H.top().first;
        H.pop();

        used[min_Node] = true;
        for (const PII &e : G[min_Node])
        if(!used[e.second])
            if (min_dist + e.first < d[e.second])
            {
                d[e.second] = min_dist + e.first;
                    H.push({d[e.second], e.second});
            }
    }

    for (int i = 2; i <= n; ++i)
    {
        if (d[i] == INF)
            d[i] = 0;

        g << d[i];

        if (i != n)
            g << ' ';
        else
            g << '\n';
    }

    return 0;
}