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 JAVA (judge verdict: Accepted)

import java.util.LinkedList;
import java.util.HashMap;
import java.util.Scanner;
import java.util.Iterator;

class Edge {
    private int srcVertex;
    private int destVertex;

    public Edge (int src, int dest) {
        srcVertex = src;
        destVertex = dest;
    }

    public boolean equals(Object other) {
        return (other instanceof Edge) && (((Edge) other).srcVertex == srcVertex) && (((Edge) other).destVertex == destVertex);
    }

    public int hashCode() {
        return srcVertex + destVertex * destVertex;
    }
}

class Graph {
	private int totalVertex;
    private LinkedList<LinkedList<Integer>> adjList;
    private HashMap<Edge, Integer> edgeMap;

    public Graph() {
        adjList = new LinkedList<>();
        edgeMap = new HashMap<>();
    }

    public void initialize() {
        Scanner input = new Scanner(System.in);
        totalVertex = input.nextInt();

        for (int i = 0; i < totalVertex; i++) {
            LinkedList<Integer> neighborList = new LinkedList<>();
            input.nextInt();
            int numNeighbors = input.nextInt();
            for (int j = 0; j < numNeighbors; j++) {
                int neighbor = input.nextInt();
                neighborList.add(neighbor);
                edgeMap.put(new Edge(i, neighbor), input.nextInt());
            }
            adjList.add(neighborList);
        }

        input.close();
    }

    public void Dijkstra() {
        int[] distances = new int[totalVertex];
        boolean[] visited = new boolean[totalVertex];

        for (int i = 1; i < distances.length; i++) {
            distances[i] = Integer.MAX_VALUE;
        }

        int currVertex = 0;
        for (int i = 0; i < totalVertex && distances[currVertex] < Integer.MAX_VALUE; i++) {
            currVertex = findMinVertex(distances, visited);
            visited[currVertex] = true;
            LinkedList<Integer> neighborList = adjList.get(currVertex);

            for (Integer neighbor : neighborList) {
                if (!visited[neighbor]) {
                    relax(currVertex, neighbor, distances, edgeMap.get(new Edge(currVertex, neighbor)));
                }
            }
        }

        for (int i = 0; i < totalVertex; i++) {
            System.out.println(i + " " + distances[i]);
        }
    }

    public int findMinVertex(int[] distances, boolean[] visited) {
        int minIndex = 0;
        for (int i = 0; i < visited.length; i++) {
            if (!visited[i]) {
                minIndex = i;
                break;
            }
        }

        for (int i = 1; i < distances.length; i++) {
            if (!visited[i] && distances[i] < distances[minIndex]) {
                minIndex = i;
            }
        }

        return minIndex;
    }

    public void relax(int src, int dest, int[] distances, int weight) {
        int newDistance = distances[src] + weight;
        if (newDistance < distances[dest]) {
            distances[dest] = newDistance;
        }
    }
}

//change class name GraphRepresentation to Main() for submission to AIZU
public class Main {
	public static void main(String argv[]) {
	Graph g = new Graph();
        g.initialize();
        g.Dijkstra();
	}
}