Problem:
Single Source Shortest Path (Negative Edges)

Input

An edge-weighted graph G (V, E) and the source r.

|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1

|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.

si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.

Output

If the graph contains a negative cycle (a cycle whose sum of edge costs is a negative value) which is reachable from the source r, print

NEGATIVE CYCLE

in a line.

Otherwise, print

c0
c1
:
c|V|-1

The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print "INF".

Constraints

1 ≤ |V| ≤ 1000

0 ≤ |E| ≤ 2000

-10000 ≤ di ≤ 10000

There are no parallel edges

There are no self-loops

Sample Input 1

4 5 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2

Sample Output 1

0
2
-3
-1

Sample Input 2

4 6 0
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2
3 1 0

Sample Output 2

NEGATIVE CYCLE

Sample Input 3

4 5 1
0 1 2
0 2 3
1 2 -5
1 3 1
2 3 2

Sample Output 3

INF
0
-5
-3

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;

namespace kozaiyApp
{
    public class SingleSourceShortestPath
    {
        static void Main()
        {
            // 入力
            string[] input = Console.ReadLine().Split(' ');
            int V = int.Parse(input[0]); // 頂点の数
            int E = int.Parse(input[1]); // 辺の数
            int r = int.Parse(input[2]); // 始点
            List<edge> edges = new List<edge>();

            for (int i = 0; i < E; i++)
            {
                string[] inputEdge = Console.ReadLine().Split(' ');
                edge edgeItem = new edge
                {
                    s = int.Parse(inputEdge[0]),
                    t = int.Parse(inputEdge[1]),
                    cost = int.Parse(inputEdge[2])
                };
                edges.Add(edgeItem);
            }

            // ベルマンフォード法
            int INF = 100000000;
            int[] k = Enumerable.Repeat<int>(INF, V).ToArray(); // 始点〜各頂点までの最短経路の重みの和
            k[r] = 0; // 始点は0にしておく

            for (int i = 0; i < V; i++) // すべての頂点をループ
            {
                foreach (var e in edges) // すべての辺をループ
                {
                    if (k[e.s] == INF) continue; // 始点〜辺の頂点sまでの最短経路がINFならループを抜ける

                    var cost = k[e.s] + e.cost;
                    if (cost < k[e.t]) // いま調べている経路の方が最小だったら
                    {
                        k[e.t] = cost; // 更新
                        if (i == V - 1) // v回目にも更新がある→負の閉路が存在する
                        {
                            Console.WriteLine("NEGATIVE CYCLE");
                            return;
                        }
                    }
                }
            }

            foreach (var ans in k)
            {
                if (ans == INF)
                {
                    Console.WriteLine("INF");
                }
                else
                {
                    Console.WriteLine(ans);
                }
            }
        }
    }

    public class edge
    {
        public int s { get; set; }
        public int t { get; set; }
        public int cost { get; set; }
    }

}