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: Runtime Error)

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

namespace ConsoleApplication1
{
    class Program
    {
        public class PriorityQueue<T> where T : IComparable
        {
            private IComparer<T> _comparer = null;
            private int _type = 0;

            private T[] _heap;
            private int _sz = 0;

            private int _count = 0;

            /// <summary>
            /// Priority Queue with custom comparer
            /// </summary>
            public PriorityQueue(int maxSize, IComparer<T> comparer)
            {
                _heap = new T[maxSize];
                _comparer = comparer;
            }

            /// <summary>
            /// Priority queue
            /// </summary>
            /// <param name="maxSize">max size</param>
            /// <param name="type">0: asc, 1:desc</param>
            public PriorityQueue(int maxSize, int type = 0)
            {
                _heap = new T[maxSize];
                _type = type;
            }

            private int Compare(T x, T y)
            {
                if (_comparer != null) return _comparer.Compare(x, y);
                return _type == 0 ? x.CompareTo(y) : y.CompareTo(x);
            }

            public void Push(T x)
            {
                _count++;

                //node number
                var i = _sz++;

                while (i > 0)
                {
                    //parent node number
                    var p = (i - 1) / 2;

                    if (Compare(_heap[p], x) <= 0) break;

                    _heap[i] = _heap[p];
                    i = p;
                }

                _heap[i] = x;
            }

            public T Pop()
            {
                _count--;

                T ret = _heap[0];
                T x = _heap[--_sz];

                int i = 0;
                while (i * 2 + 1 < _sz)
                {
                    //children
                    int a = i * 2 + 1;
                    int b = i * 2 + 2;

                    if (b < _sz && Compare(_heap[b], _heap[a]) < 0) a = b;

                    if (Compare(_heap[a], x) >= 0) break;

                    _heap[i] = _heap[a];
                    i = a;
                }

                _heap[i] = x;

                return ret;
            }

            public int Count()
            {
                return _count;
            }

            public T Peek()
            {
                return _heap[0];
            }

            public bool Contains(T x)
            {
                for (int i = 0; i < _sz; i++) if (x.Equals(_heap[i])) return true;
                return false;
            }

            public void Clear()
            {
                while (this.Count() > 0) this.Pop();
            }

            public IEnumerator<T> GetEnumerator()
            {
                var ret = new List<T>();

                while (this.Count() > 0)
                {
                    ret.Add(this.Pop());
                }

                foreach (var r in ret)
                {
                    this.Push(r);
                    yield return r;
                }
            }

            public T[] ToArray()
            {
                T[] array = new T[_sz];
                int i = 0;

                foreach (var r in this)
                {
                    array[i++] = r;
                }

                return array;
            }
        }

        public class ComparablePair<T, U> : IComparable where T : IComparable<T>
        {
            public readonly T Item1;
            public readonly U Item2;

            public int CompareTo(object obj)
            {
                ComparablePair<T, U> castedObj = (ComparablePair<T, U>)obj;
                return this.Item1.CompareTo(castedObj.Item1);
            }

            public ComparablePair(T t, U u)
            {
                Item1 = t;
                Item2 = u;
            }
        }

        /// <summary>
        /// Get min cost between two points
        /// </summary>
        public class Dijkstra
        {
            private int maxIndex = -1;
            private const int INF = Int32.MaxValue;

            private int[,] _edgeArray;

            /// <summary>
            /// Dijkstra, get min cost between two points
            /// should not contain negatie cost path
            /// </summary>
            /// <param name="size">max index of vertice</param>
            public Dijkstra(int size)
            {
                maxIndex = size + 1;
                _edgeArray = new int[maxIndex, maxIndex];

                for (int i = 0; i < _edgeArray.GetLength(0); i++)
                {
                    for (int j = 0; j < _edgeArray.GetLength(1); j++)
                    {
                        _edgeArray[i, j] = INF;
                        if (i == j) _edgeArray[i, j] = 0;
                    }
                }
            }

            // Add a path(no direction) with its cost
            public void AddPath(int s, int t, int cost)
            {
                _edgeArray[s, t] = Math.Min(_edgeArray[s, t], cost);
                //_edgeArray[t, s] = _edgeArray[s, t];  //non directed => remove comment
            }

            //Get the min cost between s and t
            //return Int32.MaxValue if no path
            public int[] GetMinCost(int s)
            {
                int[] cost = new int[maxIndex];
                for (int i = 0; i < cost.Length; i++) cost[i] = INF;
                cost[s] = 0;

                var priorityQueue = new PriorityQueue<ComparablePair<int, int>>(maxIndex);
                priorityQueue.Push(new ComparablePair<int, int>(0, s));

                while (priorityQueue.Count() > 0)
                {
                    var costDestinationPair = priorityQueue.Pop();
                    if (cost[costDestinationPair.Item2] < costDestinationPair.Item1) continue;

                    for (int i = 0; i < maxIndex; i++)
                    {
                        int newCostToi = _edgeArray[costDestinationPair.Item2, i] == INF ? INF :
                            costDestinationPair.Item1 + _edgeArray[costDestinationPair.Item2, i];
                        if (newCostToi < cost[i])
                        {
                            cost[i] = newCostToi;
                            priorityQueue.Push(new ComparablePair<int, int>(newCostToi, i));
                        }
                    }
                }

                return cost;
            }
        }

        static void Main(string[] args)
        {
            var str = Console.ReadLine().Split();
            var V = Int32.Parse(str[0]);
            var E = Int32.Parse(str[1]);
            var r = Int32.Parse(str[2]);

            var dijkstra = new Dijkstra(V - 1);

            for (int l = 0; l < E; l++)
            {
                str = Console.ReadLine().Split();
                var s = Int32.Parse(str[0]);
                var t = Int32.Parse(str[1]);
                var d = Int32.Parse(str[2]);
                dijkstra.AddPath(s, t, d);
            }

            var dist = dijkstra.GetMinCost(r);

            for (int i = 0; i < V; i++)
            {
                Console.WriteLine(dist[i] == Int32.MaxValue ? "INF" : string.Format("{0}", dist[i]));
            }
        }
    }
}