#include <fstream>
#include <algorithm>
#define oo 0x7fffffff
using namespace std;

ifstream fin("bellmanford.in");
ofstream fout("bellmanford.out");

struct graf
{
    int nod, c;
    graf *next;
};

struct muchie
{
    int x, y, c;
} M[250001];

int n, m, dist[50001], len;
bool b[50001];
graf * adj[50001];

struct noduri
{
    int a;
    bool operator<(const noduri x) const
    {
        return dist[a] > dist[x.a];
    }
} a[50001];



void add(int x, int y,  int c)
{
    graf *g = new graf;
    g->nod = y;
    g->c = c;
    g->next = adj[x];
    adj[x] = g;
}

bool bellman()
{
    int k = 0;

    //initializarea distantelor
    for (int i = 1; i <= n; i++)
        dist[i] = oo;
    dist[1] = 0;

    a[0].a = 1;
    len = 1;
    while (len && k < n)
    {
        k++;
        int nod = a[0].a, d = dist[nod];
        graf *q = adj[nod];
        b[nod] = 0;
        //pop_heap(a, a + len);//
        //len--;//
        while (q)
        {
            if (d + q->c < dist[q->nod])
            {
                dist[q->nod] = d + q->c;
                if (!b[q->nod])
                {
                    b[q->nod] = 1;
                    a[len++].a = q->nod;
                    //push_heap(a, a + len);//
                }
            }
            q = q->next;
        }
        len--;
        swap(a[0], a[len]);
        make_heap(a, a + len);
    }
    for (int i = 1; i <= n; i++)
    {
        int d = dist[i];
        graf *q = adj[i];
        while (q)
        {
            if (d + q->c < dist[q->nod])
                return false;
            q = q->next;
        }
    }


    return true;
}

int main()
{
    int x, y, c;

    fin >> n >> m;
    for (int i = 0; i < m; i++)
    {
        fin >> x >> y >> c;
        add(x, y, c);
    }

    if(!bellman())
        fout << "Ciclu negativ!";
    else
        for (int i = 2; i <= n; i++)
            fout << dist[i] << ' ';

}