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

#define MAXN 50001

class EdgeTo {
public:
    int node;
    int cost;

    EdgeTo(int node, int cost) {
        this->node = node;
        this->cost = cost;
    }
};

class Edge {
public:
    int u;
    int v;
    int cost;

    Edge(int u, int v, int c) {
        this->u = u;
        this->v = v;
        this->cost = c;
    }
};

int n, m;
vector<vector<EdgeTo>> adj(MAXN); 
vector<Edge> all_edges;
vector<long> distances;
bool found_cycles = false;

void read() {
    fstream fin("bellmanford.in", ios::in);
    fin >> n >> m;

    for (int i = 0; i < m; i++) {
        int x, y, c;
        fin >> x >> y >> c;
        adj[x].push_back(EdgeTo(y, c));
        all_edges.push_back(Edge(x, y, c));
    }

    fin.close();
}

void bellman_ford(int source) {
    for (int i = 0; i <= n; i++) {
        distances.push_back(1 << 29);
    }
    distances[source] = 0;


    for (int i = 1; i <= n; i++) {
        for (Edge edge : all_edges) {
            if (distances[edge.v] > distances[edge.u] + edge.cost) {
                distances[edge.v] = distances[edge.u] + edge.cost;
            }
        }
    }

    for (Edge edge : all_edges) {
        if (distances[edge.v] > distances[edge.u] + edge.cost) {
            found_cycles = true;
            break;
        }
    }
}

void write() {
    fstream fout("bellmanford.out", ios::out);
    if (found_cycles == false) {
        for (int i = 2; i <= n; i++) {
            if (distances[i] == 1 << 29) {
                fout << 0 << " ";   
            } else {
                fout << distances[i] << " ";
            }
        }
    } else {
        fout << "Ciclu negativ!";
    }

    fout.close();
}

int main() {
    read();
    bellman_ford(1);
    write();
    return 0;
}