Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Single Source Shortest Path II

For a given weighted graph $G = (V, E)$, find the shortest path from a source to each vertex. For each vertex $u$, print the total weight of edges on the shortest path from vertex $0$ to $u$.

Input

In the first line, an integer $n$ denoting the number of vertices in $G$ is given. In the following $n$ lines, adjacency lists for each vertex $u$ are respectively given in the following format:

$u$ $k$ $v_1$ $c_1$ $v_2$ $c_2$ ... $v_k$ $c_k$

Vertices in $G$ are named with IDs $0, 1, ..., n-1$. $u$ is ID of the target vertex and $k$ denotes its degree. $v_i (i = 1, 2, ... k)$ denote IDs of vertices adjacent to $u$ and $c_i$ denotes the weight of a directed edge connecting $u$ and $v_i$ (from $u$ to $v_i$).

Output

For each vertex, print its ID and the distance separated by a space character in a line respectively. Print in order of vertex IDs.

Constraints

$1 \leq n \leq 10,000$

$0 \leq c_i \leq 100,000$

$|E| < 500,000$

All vertices are reachable from vertex $0$

Sample Input 1

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

Sample Output 1

0 0
1 2
2 2
3 1
4 3

Reference

Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. The MIT Press.

Solution in C# (judge verdict: Accepted)

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

namespace Practice
{
    class Program
    {
        const int WHITE = -10;
        const int GRAY = -9;
        const int BLACK = -8;
        const int NOEDGE = int.MaxValue;
        public struct Node : IComparable
        {
            public int v;
            public int w;
            public Node(int v, int w)
            {
                this.v = v;
                this.w = w;
            }

            public int CompareTo(Object obj)
            {
                Node n = (Node)obj;
                return this.w.CompareTo(n.w);
            }
        }
        static void Main(string[] args)
        {
            SolveA(args);
            //SolveB(args);
            //SolveC(args);
            //SolveD(args);


        }
        static void SolveA(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            List<Node>[] m = new List<Node>[n];
            
            for(int i=0;i<n;++i)
            {
                m[i] = new List<Practice.Program.Node>();
            }
            for(int i = 0; i < n; ++i)
            {
                var szarr = Console.ReadLine().Split(' ');
                int U = int.Parse(szarr[0]);
                int k = int.Parse(szarr[1]);
                for(int j=0;j<k;++j)
                {
                    int v = int.Parse(szarr[j * 2 + 2]);
                    int c = int.Parse(szarr[j * 2 + 3]);
                    m[U].Add(new Node(v, c));
                }
            }

            int[] color = new int[n];
            int[] d = new int[n];
            PriorityQueue<Node> pq = new PriorityQueue<Node>(n*n);

            dijkstra(0, n, m, color, d, pq);

            for(int i=0;i<d.Length;++i)
            {
                string sz = i + " " + d[i];
                Console.WriteLine(sz);
            }
        }
        static void dijkstra(int s ,int n ,List<Node>[] m, int [] color, int[] d,  PriorityQueue<Node> pq)
        {
            for(int i = 0; i < color.Length; ++i) { color[i] = WHITE; }
            for(int i = 0; i < d.Length; ++i) { d[i] = int.MaxValue; }
            d[s] = 0;
            pq.Push(new Node(s, 0));
            while(pq.Count() >= 1)
            {
                Node minNode  = pq.Pop();
                int u = minNode.v;
                color[u] = BLACK;

                if( d[u] < minNode.w)
                {
                    continue;
                }
                foreach(Node tmpNode in m[u])
                {
                    int v = tmpNode.v;
                    if( color[v] != BLACK)
                    {
                        if(d[u] + tmpNode.w < d[v])
                        {
                            d[v] = d[u] + tmpNode.w;
                            color[v] = GRAY;
                            pq.Push(new Node(v, d[v]));
                        }
                    }
                }
            }
        }
    }
    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;
        }
    }
}