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

Single Source Shortest Path

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 100$

$0 \leq c_i \leq 100,000$

$|E| \leq 10,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 _20190129_AOJ
{
    class ALDS1_12B
    {
        static void Main(string[] args)
        {
            for (;;)
            {
                string line = Console.ReadLine();
                if (string.IsNullOrEmpty(line))
                {
                    break;
                }

                int n = int.Parse(line);
                int[,] map = CreateMap(n);
                for (int i = 0; i < n; i++)
                {
                    int[] iarr = ReadIntArr();
                    for (int j = 2; j < iarr.Length; j += 2)
                    {
                        map[i, iarr[j]] = iarr[j + 1];
                    }
                }

                int[] d = new int[n];
                for(int i=1;i<n;i++)
                {
                    d[i] = int.MaxValue;
                }
                int[] prev = Enumerable.Repeat<int>(-1, n).ToArray();

                HashSet<int> Q = new HashSet<int>();
                for (int i = 0; i < n; i++)
                {
                    Q.Add(i);
                }

                while (Q.Count > 0)
                {
                    int u = PopMin(Q, d);
                    for (int v = 0; v < n; v++)
                    {
                        int len = map[u, v];
                        if (len >= 0)
                        {
                            if (d[v] > d[u] + len)
                            {
                                d[v] = d[u] + len;
                                prev[v] = u;
                            }
                        }
                    }
                }

                for (int i = 0; i < n; i++)
                {
                    Console.WriteLine("{0} {1}", i, d[i]);
                }
            }
        }

        static int GetMinIndex(int[] arr)
        {
            int idx = 0;
            int min = arr[0];
            for(int i=1;i<arr.Length;i++)
            {
                if (min > arr[i])
                {
                    min = arr[i];
                    idx = i;
                }
            }

            return idx;
        }

        static int PopMin(HashSet<int> q, int[] d)
        {
            int min = int.MaxValue;
            int rv = -1;
            foreach (var v in q)
            {
                if (min > d[v])
                {
                    min = d[v];
                    rv = v;
                }
            }

            q.Remove(rv);

            return rv;
        }

        static int[,] CreateMap(int n)
        {
            int[,] map = new int[n, n];
            for(int i=0;i<n;i++)
            {
                for(int j=0;j<n;j++)
                {
                    map[i, j] = -1;
                }
            }
            return map;
        }

        static int ReadInt() { return int.Parse(Console.ReadLine()); }
        static double ReadDouble() { return double.Parse(Console.ReadLine()); }
        static int[] ReadIntArr(char dlm = ' ') { return Console.ReadLine().Split(dlm).Select(x => int.Parse(x)).ToArray(); }
        static double[] ReadDoubleArr(char dlm = ' ') { return Console.ReadLine().Split(dlm).Select(x => double.Parse(x)).ToArray(); }
        static string[] ReadStringArr(char dlm = ' ') { return Console.ReadLine().Split(dlm).ToArray(); }
    }
}