#include <algorithm>
#include <fstream>
#include <iterator>
#include <limits>
#include <queue>
#include <tuple>
#include <utility>
#include <vector>

using edge_t = std::pair<int, int>;
using min_heap_t = std::priority_queue<edge_t, std::vector<edge_t>, std::greater<edge_t>>;
using adjancency_list_t = std::vector<std::vector<edge_t>>;

adjancency_list_t read();
void write(const std::vector<int> &D);

std::vector<int> solve(adjancency_list_t &G)
{
    std::vector<int> D(G.size(), std::numeric_limits<int>::max());
    min_heap_t H;

    D[0] = 0;
    H.push(std::make_pair(0, 0));

    while (!H.empty())
    {
        int min, u;
        std::tie(min, u) = H.top();
        H.pop();

        if (min == D[u])
        {
            for (auto edge : G[u])
            {
                if (D[edge.second] > D[u] + edge.first)
                {
                    D[edge.second] = D[u] + edge.first;
                    H.push(std::make_pair(D[edge.second], edge.second));
                }
            }
        }
    }

    for (size_t i = 0; i < D.size(); i++)
    {
        D[i] = D[i] == std::numeric_limits<int>::max() ? 0 : D[i];
    }

    return D;
}

int main()
{
    auto G = read();
    auto D = solve(G);
    write(D);

    return 0;
}

adjancency_list_t read()
{
    std::ifstream fin("dijkstra.in");
    int N, V;

    fin >> N >> V;

    adjancency_list_t G(N, std::vector<edge_t>());

    int u, v, c;
    while (fin >> u >> v >> c)
    {
        u--, v--;
        G[u].push_back(std::make_pair(c, v));
    }

    return G;
}

void write(const std::vector<int> &D)
{
    std::ofstream fout("dijkstra.out");

    std::copy_n(D.begin() + 1, D.size() - 1, std::ostream_iterator<int>(fout, " "));
    fout << '\n';
}