/**
  *  Worg
  */
#include <queue>
#include <cstdio>
#include <vector>
#include <utility>
#include <algorithm>

FILE *fin = freopen("dijkstra.in", "r", stdin);
FILE *fout = freopen("dijkstra.out", "w", stdout);

const int INF = 1e9 + 10;

struct NodeDist {
  int vertex;
  int dist;

  NodeDist(const int &_vertex, const int &_dist) {
    this->vertex = _vertex;
    this->dist = _dist;
  }

  bool operator <(const NodeDist &other) const {
    return this->dist > other.dist;
  }
};

class Solver {
private:
    int n, m;
    std::vector<std::vector<std::pair<int, int>>> graph;

public:
    Solver() {}

    void init_graph() {
        graph = std::vector<std::vector<std::pair<int, int>>>(n);
    }

    void read_data() {
        scanf("%d%d", &n, &m);

        init_graph();

        for (int i = 0; i < m; i++) {
            int u, v, w;
            scanf("%d%d%d", &u, &v, &w);
            u -= 1; v -= 1;
            graph[u].emplace_back(v, w);
            graph[v].emplace_back(u, w);
        }
    }

    void run_dijkstra() {
        std::vector<int> min_dist(n, INF);
        std::priority_queue<NodeDist> heap;

        heap.emplace(0, 0);

        while (!heap.empty()) {
            int node = heap.top().vertex;
            int node_dist = heap.top().dist;

            heap.pop();

            if (min_dist[node] == INF) {
                min_dist[node] = node_dist;

                for (const auto& edge: graph[node]) {
                    if (min_dist[edge.first] == INF) {
                        heap.emplace(edge.first, node_dist + edge.second);
                    }
                }
            }
        }

        for (int i = 1; i < n; i++) {
            int ans = min_dist[i] == INF ? 0 : min_dist[i];
            printf("%d ", ans);
        }
    }
};

int main() {
    Solver s;
    s.read_data();
    s.run_dijkstra();
    return 0;
}