#include <iostream>
#include <fstream>
#include <vector>
#include <deque>
#include <stack>
#include <tuple>
#include <queue>
#include <list>

using namespace std;

class Graph {
    struct nodeStruct {
        int node, cost;
        bool operator()(nodeStruct const& n1, nodeStruct const& n2) { return n1.cost > n2.cost; }
    };
    vector<list<nodeStruct>> adjacent;
    vector<list<nodeStruct>> transposed() {
        vector<list<nodeStruct>> ret(adjacent.size());
        for(int i = 0; i < adjacent.size(); i++)
            for(nodeStruct node: adjacent[i])
                ret[node.node].push_back(nodeStruct({i, node.cost}));
        return ret;
    }
    void dfs(int current, vector<bool> &visited, stack<int> &order) {
        visited[current] = true;
        for(auto i: adjacent[current])
            if(!visited[i.node])
                dfs(i.node, visited, order);
        order.push(current);
    }
    void bfs(int current, vector<int> &costs, vector<bool> &visited, deque<int> &queue) {
        queue.push_back(current);
        visited[current] = true;
        costs[current] = 0;
        while(queue.empty() != 1) {
            int k = queue.front();
            for(auto i: adjacent[k])
                if(!visited[i.node]) {
                    costs[i.node] += (costs[k] + 1);
                    visited[i.node] = true;
                    queue.push_back(i.node);
                }
            queue.pop_front();
        }
    }
    void _biconnected(int node, int daddy, vector<bool> &visited, vector<int> &level, vector<int> &minLevel, stack<int> &s, vector<vector<int>> &components, vector<pair<int,int>> &criticalEdges) {
        visited[node] = true;
        minLevel[node] = level[node] = level[daddy] + 1;
        s.push(node);
        for (auto x: adjacent[node])
            if (x.node != daddy) {
                if (visited[x.node])
                    minLevel[node] = min(minLevel[node], level[x.node]);
                else {
                    _biconnected(x.node, node, visited, level, minLevel, s, components, criticalEdges);
                    minLevel[node] = min(minLevel[node], minLevel[x.node]);
                    if(level[node] < minLevel[x.node])
                        criticalEdges.emplace_back(node, x.node);
                    if (minLevel[x.node] >= level[node]) {
                        components.resize(components.size()+1);
                        while (s.top() != x.node) {
                            components[components.size()-1].push_back(s.top());
                            s.pop();
                        }
                        components[components.size()-1].push_back(x.node);
                        s.pop();
                        components[components.size()-1].push_back(node);
                    }
                }
            }
    }
    void _hardConnected(int node, vector<bool> &visited, vector<vector<int>> &components, vector<list<nodeStruct>> &t) {
        visited[node] = false;
        components[components.size() - 1].push_back(node);
        for(auto j: t[node])
            if(visited[j.node])
                _hardConnected(j.node, visited, components, t);
    }
public:
    Graph(vector<tuple<int, int, int>> &data, int nrNodes, bool oriented=true) {
        adjacent.resize(nrNodes);
        for(auto[node1, node2, cost]: data) {
            adjacent[node1].push_back(nodeStruct({node2, cost}));
            if(!oriented)
                adjacent[node2].push_back(nodeStruct({node1, cost}));
        }
    }
    friend ostream& operator<< (ostream& os, Graph graph) {
        os << graph.adjacent.size() << " nodes\n";
        for(int i = 0; i < graph.adjacent.size(); i++) {
            os << "node " << i << ": ";
            for(nodeStruct j: graph.adjacent[i])
                os << "(" << j.node << ", " << j.cost << ") ";
            os << "\n";
        }
        return os;
    }
    int connected() {
        vector<bool> visited(adjacent.size());
        int nr = 0;
        for(int i = 0; i < adjacent.size(); i++)
            if(!visited[i]) {
                stack<int> _;
                nr++;
                dfs(i, visited, _);
            }
        return nr;
    }
    pair<vector<int>, vector<bool>> costs(int start) {
        vector<int> costs(adjacent.size());
        vector<bool> visited(adjacent.size());
        deque<int> queue;
        bfs(start, costs, visited, queue);
        return make_pair(costs, visited);
    }
    stack<int> topologicalSort() {
        vector<bool> visited(adjacent.size());
        stack<int> order;
        for(int i = 0; i < adjacent.size(); i++)
            if(!visited[i])
                dfs(i, visited, order);
        return order;
    }
    pair<vector<vector<int>>, vector<pair<int,int>>> biconnected(){
        stack<int> s;
        vector<int> level(adjacent.size()), minLevel(adjacent.size());
        vector<bool> visited(adjacent.size());
        vector<vector<int>> components;
        vector<pair<int,int>> criticalEdges;
        for (int i = 0; i < adjacent.size(); i++)
            if (visited[i] == 0)
                _biconnected(i, 0, visited, level, minLevel, s, components, criticalEdges);
        return make_pair(components, criticalEdges);
    }
    vector<vector<int>> hardConnected() {
        stack<int> s;
        vector<bool> visited(adjacent.size());
        vector<vector<int>> components;
        vector<list<nodeStruct>> t = transposed();
        for(int i = 0; i < adjacent.size(); i++)
            if(!visited[i])
                dfs(i, visited, s);
        while(!s.empty()){
            if(visited[s.top()]){
                components.resize(components.size() + 1);
                _hardConnected(s.top(), visited, components, t);
            }
            s.pop();
        }
        return components;
    }
    pair<vector<int>, bool> dijkstraBellman(int start) {
        const int inf = 250001;
        vector<int> visited(adjacent.size()), distance(adjacent.size(), inf);
        priority_queue<nodeStruct, vector<nodeStruct>, nodeStruct> costs;
        costs.push({start, 0});
        distance[start] = 0;
        while(costs.empty() != 1) {
            int node = costs.top().node;
            costs.pop();
            for(auto i: adjacent[node]){
                    if(distance[i.node] == inf || distance[i.node] > i.cost + distance[node]){
                        distance[i.node] = i.cost + distance[node];
                        costs.push({i.node, distance[i.node]});
                        visited[node]++;
                        if(visited[i.node] >= adjacent.size())
                            return make_pair(distance, 1);
                    }
            }
            visited[node]++;
        }
        return make_pair(distance, 0);
    }
};

int main() {
    ifstream in("dijkstra.in");
    ofstream out("dijkstra.out");
    vector<tuple<int, int, int>> data;
    int n, m, start;
    in >> n >> m; // >> start;
    for(int i = 0; i < m; i++) {
        int aux1, aux2, cost;
        in >> aux1 >> aux2 >> cost;
        data.emplace_back(aux1 - 1, aux2 - 1, cost);
//        data.emplace_back(aux2 - 1, aux1 - 1, 0);
    }
    Graph g(data, n);

    auto dijks = g.dijkstraBellman(0);
    if(dijks.second)
        out << "Ciclu negativ!";
    else for(int i = 1; i < dijks.first.size(); i++)
            out << dijks.first[i] << " ";

//    out << g.connected();


//    auto components = g.hardConnected();
//    out << components.size() << "\n";
//        for(auto j: component)
//            out << j + 1 << " ";
//        out << "\n";
//    }

//    auto rez = g.biconnected();
//    out << rez.first.size() << "\n";
//    for(const auto& connected: rez.first) {
//        for(auto node: connected)
//            out << node + 1 << " ";
//        out << "\n";
//    }
//    for(auto [x, y] : rez.second)
//        cout << "(" << x + 1 << ", " << y + 1 << ") ";
    return 0;
}