Problem:
Single Source Shortest Path

For a given weighted graph G(V, E) and a source r, find the source shortest path to each vertex from the source (SSSP: Single Source Shortest Path).

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

Print the costs of SSSP in the following format.

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| ≤ 100000

0 ≤ di ≤ 10000

0 ≤ |E| ≤ 500000

There are no parallel edges

There are no self-loops

Sample Input 1

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

Sample Output 1

0
1
3
4

Sample Input 2

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

Sample Output 2

3
0
2
INF

Solution in C# (judge verdict: Accepted)



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

class Program {

    static int MX = 6;
    const int wht = 6, gry = 1, blk = 2;
    const long inf = long.MaxValue;

    static List<Edge> edges = null;
    static long[] d = null;




    class Edge {
        public int frm, to, cst;
        public Edge(int pf, int pt, int pc) {
            frm = pf;
            to = pt;
            cst = pc;
        }
        public string prt() {
            return "eg:" + frm.ToString() + "-" + to.ToString() + " " + cst.ToString();
        }
    }


    static bool shortestPath(int src) {

        for (int i = 0; i < MX; i++) {
            d[i] = inf;
        }
        d[src] = 0;

        int cnt = 0;
        bool updated = true;

        while (updated) {
            updated = false;
            foreach (var eg in edges) {
                if (d[eg.frm] != inf && d[eg.to] > d[eg.frm] + eg.cst) {
                    d[eg.to] = d[eg.frm] + eg.cst;
                    updated = true;
                    if (cnt == MX - 1) return false;
                }
            }
            cnt++;
        }
        return true;
    }

    static void Main(string[] args) {
    

        var inp = Console.ReadLine().Split(' ').Select(z => int.Parse(z)).ToArray();
        int v, e; v = inp[0]; e = inp[1];

        int stt = inp[2];

        MX = v;
        edges = new List<Edge>();
        d = new long[MX];


        for (int i = 0; i < e; i++) {
            var c = Console.ReadLine().Split(' ').Select(z => int.Parse(z)).ToArray();

            edges.Add(new Edge(c[0], c[1], c[2]));
        }


        bool ngCyc = false, tmp = false;
        string str = "";

        tmp = shortestPath(stt);
        if (!tmp) {
            ngCyc = true;
        }

        if (ngCyc) Console.WriteLine("NEGATIVE CYCLE");
        else {
            string s = "";
            foreach (var dst in d) {
                if (s.Length > 0) s += " ";
                s = dst == inf ? "INF" : dst.ToString();
                Console.WriteLine(s);
            }

        }

    }
}