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 Ruby (judge verdict: Wrong Answer)

# coding: utf-8
#
# :u ノードのインデックス
# :k u の出次数
# :v u に隣接する頂点の番号
# :w 隣接する頂点への重み
# :d 距離
# :p 前のノード
#

INF  = Float::INFINITY
Node = Struct.new(:u, :k, :v, :w, :d, :p)

class Graph
  attr :nodes
  def initialize(n)
    @nodes = Array.new(n){ Node.new }
    @nodes = @nodes.map.with_index do |node,idx|
      node.u = idx
      node.d = INF
      node.p = nil
      node.v = []
      node
    end
  end

  def add_graph_edge(u, v, w)
    #puts "#{u} -> #{v} (#{w})"
    if @nodes[u].v.empty?
      @nodes[u].v = [v]
      @nodes[u].w = {v=>w}
    elsif @nodes[u].v.is_a?(Array)
      @nodes[u].v << v
      @nodes[u].w = {v=>w}.merge(@nodes[u].w)
    else
      @nodes[u].v = [@nodes[u].v, v]
      @nodes[u].w = {v=>w}.merge(@nodes[u].w)
    end
    @nodes[u].k = if @nodes[u].v.is_a?(Array)
                    @nodes[u].v.length
                  else
                    1
                  end
  end

  def bellman_ford(source=0)
    @nodes[source].d = 0

    for i in 0...@nodes.length
      for uv in @nodes[i].v
        u = @nodes[i].u
        v = @nodes[uv].u
        if @nodes[v].d > @nodes[u].d + @nodes[u].w[v]
          @nodes[v].d = @nodes[u].d + @nodes[u].w[v]
          @nodes[v].p = u
        end
      end
    end
  end

  def has_negative_cycle?()
    for node in @nodes
      for v in node.v
        u = node.u
        if @nodes[u].d + @nodes[u].w[v] < @nodes[v].d
          return true
        end
      end
    end
    false
  end
end

lines = $stdin.read
array = lines.split("\n")

V,E,R = array[0].split(" ").map(&:to_i)
graph = Graph.new(V)

array[1..E].each do |s|
  s,t,d = s.split(" ").map(&:to_i)
  graph.add_graph_edge(s,t,d)
end

graph.bellman_ford(R)

if graph.has_negative_cycle?
  puts "NEGATIVE CYCLE"
else
  graph.nodes.each do |n|
    if n.d == INF
      puts "INF"
    else
      puts n.d
    end
  end
end