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

#define FORIT(it,v) for(typeof((v).begin())it=(v).begin();it!=(v).end();++it)
const int MAX_N = 50100;
const int INF = 1 << 30;
ifstream fin("dijkstra.in");
ofstream fout("dijkstra.out");

int N, M;
vector<pair<int, int> > graph[MAX_N];
int cost[MAX_N];
bool visited[MAX_N];

void read_input();
void dijkstra(int start_node);
void print_output();

int main() {
    read_input();
    dijkstra(1);
    print_output();
    return 0;
}

void read_input() {
    fin >> N >> M;
    for (int i = 1; i <= M; ++i) {
        int a, b, c;
        fin >> a >> b >> c;
        graph[a].push_back(make_pair(b, c));
        graph[b].push_back(make_pair(a, c));
    }
}

struct HeapCmp {
    bool operator() (const int& lhs, const int& rhs) const {
        return cost[lhs] < cost[rhs];
    }
};

void dijkstra(int start_node) {
    fill(cost, cost + N + 1, INF);
    cost[start_node] = 0;

 //   priority_queue<int, vector<int>, HeapCmp> heap;
    set <int, HeapCmp> heap;
    heap.insert(start_node);
    
    while (!heap.empty()) {
        set<int>::iterator top = heap.begin();
        int node = *top;
        heap.erase(top);

        if (!visited[node]) {
            visited[node] = true;
            FORIT (it, graph[node]) {
                if (cost[node] + it->second < cost[it->first]) {
                    heap.erase ( it->first );
                    cost[it->first] = cost[node] + it->second;
                    heap.insert(it->first);
                }
            }
        }
    }
}

void print_output() {
    for (int i = 2; i <= N; ++i) {
        fout << (cost[i] == INF ? 0 : cost[i]) << ' ';
    }
}