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.Linq;
using System.Collections.Generic;
using static System.Console;
using System.Text;
using System.IO;

namespace AOJ
{
    class Program
    {
        static public long[] Sarray() { return ReadLine().Trim().Split().Select(long.Parse).ToArray(); }
        static public List<long> Slist() { return ReadLine().Split().Select(long.Parse).ToList(); }

        static readonly int WHITE = 0;
        static readonly int GRAY = 1;
        static readonly int BLACK = 2;

        class priority_queue<T>
        {
            Comparison<T> cmp;
            T[] A = new T[2000000];
            public priority_queue(Comparison<T> c)
            {
                cmp = c;
            }
            public int num { get; private set; } = 0;
            public void insert(T v)
            {
                A[num] = v;
                ++num;
                increaseKey(num);
            }
            void increaseKey(int i)
            {
                while (1 < i && 0 < cmp(A[i - 1], A[i / 2 - 1]))
                {
                    var t = A[i - 1];
                    A[i - 1] = A[i / 2 - 1];
                    A[i / 2 - 1] = t;
                    i = i / 2;
                }
            }
            public T extract()
            {
                if (num < 1) return default(T);
                var max = A[0];
                A[0] = A[num - 1];
                --num;
                maxHeapify(1);
                return max;
            }
            void maxHeapify(int i)
            {
                var H = num;
                var l = left(i);
                var r = right(i);
                var largest = 0;
                if (l <= H && 0 < cmp(A[l - 1], A[i - 1]))
                { largest = l; }
                else
                { largest = i; }
                if (r <= H && 0 < cmp(A[r - 1], A[largest - 1]))
                { largest = r; }
                if (largest != i)
                {
                    var t = A[i - 1];
                    A[i - 1] = A[largest - 1];
                    A[largest - 1] = t;
                    maxHeapify(largest);
                }
            }
            int left(int l) => l * 2;
            int right(int r) => r * 2 + 1;
        }

        static long[] dijkstra(long n, List<KeyValuePair<long, long>>[] M)
        {
            var q = new priority_queue<KeyValuePair<long, long>>((l, r) => (int)(r.Value - l.Value));
            var d = new long[n];
            var color = new long[n];
            for (var i = 0; i < n; ++i)
            {
                d[i] = long.MaxValue;
                color[i] = WHITE;
            }
            d[0] = 0;
            color[0] = GRAY;
            q.insert(new KeyValuePair<long, long>(0, 0));
            while (0 < q.num)
            {
                var v = q.extract();
                var u = v.Key;
                color[u] = BLACK;
                if (d[u] < v.Value) continue;
                foreach (var kv in M[u])
                {
                    var ky = kv.Key;
                    var vl = kv.Value;
                    if (color[ky] == BLACK) continue;
                    if (d[u] + vl < d[ky])
                    {
                        d[ky] = d[u] + vl;
                        q.insert(new KeyValuePair<long, long>(ky, d[ky]));
                    }
                }
            }
            return d;
        }

        static void Main(string[] args)
        {
            var N = Sarray()[0];

            var M = new List<KeyValuePair<long, long>>[N];
            for (var i = 0; i < N; ++i)
            {
                M[i] = new List<KeyValuePair<long, long>>();
                var line = Sarray();
                for (var j = 2; j < line.Length; j += 2)
                { M[i].Add(new KeyValuePair<long, long>(line[j], line[j + 1])); }
            }
            var dst = dijkstra(N, M); 
            for(var i=0;i<N;++i)
            {
                WriteLine($"{i} {dst[i]}");
            }
        }
    }
}