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.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 + 1];
                _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 + 1];
                _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 class Edge
            {
                public int T { get; set; }
                public int C { get; set; }
            }

            private int maxIndex = -1;
            private const int INF = Int32.MaxValue;

            private Dictionary<int, List<Edge>> _edgeArray = new Dictionary<int, List<Edge>>();

            /// <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;
            }

            // Add a path with its cost
            public void AddPath(int s, int t, int cost)
            {
                if (!_edgeArray.ContainsKey(s)) _edgeArray.Add(s, new List<Edge>());
                _edgeArray[s].Add(new Edge() { T = t, C = cost });
            }

            //Get the min cost from s
            //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>>(_edgeArray.Sum( e => e.Value.Count()) + 1);
                priorityQueue.Push(new ComparablePair<int, int>(0, s));

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

                    foreach (var edge in _edgeArray[costDestinationPair.Item2])
                    {
                        var newCostToi = costDestinationPair.Item1 + edge.C;
                        if (newCostToi < cost[edge.T])
                        {
                            cost[edge.T] = newCostToi;
                            priorityQueue.Push(new ComparablePair<int, int>(newCostToi, edge.T));
                        }
                    }
                }

                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]));
            }
        }
    }
}