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.Linq;
using System.Text;

namespace ALDS1_12_B_SingleSourceShortestPathI
{
	class Program
	{
		static void Main ( string[] args )
		{
			int dataCount = int.Parse (Console.ReadLine ());
			Graph graph = new Graph (dataCount);

			for (int lp = 0; lp < dataCount; lp++)
			{
				int[] inputNum = Array.ConvertAll (Console.ReadLine ().Split (' '), int.Parse);

				for (int lp2 = 0; lp2 < inputNum[1]; lp2++)
				{
					graph.GetPath (inputNum[0], inputNum[lp2 * 2 + 2], inputNum[lp2 * 2 + 3]);
				}
			}

			int[] result = graph.Dijkstra (0);

			StringBuilder output = new StringBuilder (dataCount * 6);
			int count = 0;

			foreach (var item in result)
			{
				output.Append (count);
				output.Append (" ");
				output.Append (item);
				output.AppendLine ();
				count++;
			}

			Console.Write (output);
		}
	}

	class Graph
	{
		public Graph ( int size )
		{
			this.Size = size;

			this.Path = new int[size][];
			for (int lp = 0; lp < this.Size; lp++)
			{
				this.Path[lp] = Enumerable.Repeat (Infinity, this.Size).ToArray ();
			}
		}

		private int[][] Path { set; get; }
		private const int Infinity = int.MaxValue;
		private int Size { set; get; }	

		public void GetPath ( int beginPoint, int adjacencyPoint,int cost )
		{
			Path[beginPoint][adjacencyPoint] = cost;
		}

		public int[] Dijkstra ( int beginPoint )
		{
			const int Stay = 1;
			const int Visited = 2;
			int[] visitState = new int[Size];

			const int Infinity=int.MaxValue;
			int[] distance = Enumerable.Repeat (Infinity, Size).ToArray ();

			int[] parent = new int[Size];

			distance[beginPoint] = 0;
			parent[beginPoint] = -1;

			while (true)
			{
				int minCost = Infinity;
				int parentIndex = 0;

				for (int lp = 0; lp < Size; lp++)
				{
					if (visitState[lp] != Visited && distance[lp] < minCost)
					{
						minCost = distance[lp];
						parentIndex = lp;
					}
				}

				if (minCost == Infinity)
				{
					break;
				}

				visitState[parentIndex] = Visited;

				for (int lp = 0; lp < Size; lp++)
				{
					if (visitState[lp] != Visited && Path[parentIndex][lp] != Infinity)
					{
						//?????????????????????????????????????????????
						if (distance[parentIndex] + Path[parentIndex][lp] < distance[lp])
						{
							distance[lp] = distance[parentIndex] + Path[parentIndex][lp];
							parent[lp] = parentIndex;
							visitState[lp] = Stay;
						}
					}
				}
			}

			return distance;
		}
	}
}