Problem:
Single Source Shortest Path

For a given weighted graph G(V, E) and a source r, find the source shortest path to each vertex from the source (SSSP: Single Source Shortest Path).

Input

An edge-weighted graph G (V, E) and the source r.

|V| |E| r
s0 t0 d0
s1 t1 d1
:
s|E|-1 t|E|-1 d|E|-1

|V| is the number of vertices and |E| is the number of edges in G. The graph vertices are named with the numbers 0, 1,..., |V|-1 respectively. r is the source of the graph.

si and ti represent source and target vertices of i-th edge (directed) and di represents the cost of the i-th edge.

Output

Print the costs of SSSP in the following format.

c0
c1
:
c|V|-1

The output consists of |V| lines. Print the cost of the shortest path from the source r to each vertex 0, 1, ... |V|-1 in order. If there is no path from the source to a vertex, print INF.

Constraints

1 ≤ |V| ≤ 100000

0 ≤ di ≤ 10000

0 ≤ |E| ≤ 500000

There are no parallel edges

There are no self-loops

Sample Input 1

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

Sample Output 1

0
1
3
4

Sample Input 2

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

Sample Output 2

3
0
2
INF

Solution in JAVA (judge verdict: Memory Limit Exceeded)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

/**
 * Created by huzhejie on 2016/10/9.
 */
public class Main {
    private static int adjacentMatrix[][];
    private static int vertice,edges,source;

    /**
     * deal with the first line written in the input file
     * @param s
     */
    private static void initMatrix(String s){
        String init[] = s.split(" ");
        try{
            vertice = Integer.parseInt(init[0]);
            edges = Integer.parseInt(init[1]);
            source = Integer.parseInt(init[2]);
        }catch (NumberFormatException e){
            System.out.println("You have to input positive numbers!");
        }catch (IndexOutOfBoundsException e){
            System.out.println("You have missed something when doing input!");
        }

    }

    /**
     * deal with the lines(sourceVertex targetVertex distance) written in the input file
     * @param input
     */

    private static void inputProcess(String input){
        String line[] = input.split(" ");
        try {
            int sourceVertex = Integer.parseInt(line[0]);
            int targetVertex = Integer.parseInt(line[1]);
            int distance = Integer.parseInt(line[2]);
            adjacentMatrix[sourceVertex][targetVertex] = distance;
        }catch (IndexOutOfBoundsException e){
            System.out.println("You have missed something when doing input!");
        }catch (NumberFormatException e){
            System.out.println("You have to input positive numbers!");
        }
    }

    /**
     *
     * @param dist  to keep record of the shortest distance between source vertex and target vertices
     */
    private static void dijkstra(int dist[]){

        boolean[] flag = new boolean[vertice];

        for (int i = 0; i < vertice; i++) {
            flag[i] = false;
            dist[i] = adjacentMatrix[source][i];
        }
        flag[source] = true;
        dist[source] = 0;
        int k=0;
        for (int i = 1; i < vertice; i++) {
            int min = Integer.MAX_VALUE;
            for (int j = 0; j < vertice; j++) {
                if (flag[j]==false && dist[j]<min) {
                    min = dist[j];
                    k = j;
                }
            }
            flag[k] = true;
            for (int j = 0; j < vertice; j++) {
                int tmp = (adjacentMatrix[k][j]==Integer.MAX_VALUE ? Integer.MAX_VALUE : (min + adjacentMatrix[k][j]));
                if (flag[j]==false && tmp<dist[j]) {
                    dist[j] = tmp;
                }
            }
        }

        for (int i=0; i < vertice; i++) {
            if (dist[i] == Integer.MAX_VALUE)
                System.out.println("INF");
            else
                System.out.println(dist[i]);
        }
    }

    public static void main(String ars[]){
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int lineCount = 1;
        String str=null;
        try {
            initMatrix(br.readLine());
        }catch (IOException e){
            e.printStackTrace();
        }
        adjacentMatrix = new int[vertice][vertice];
        for (int i = 0;i<vertice;i++){
            Arrays.fill(adjacentMatrix[i],Integer.MAX_VALUE);
        }
        try {
            while ((str = br.readLine()) != null && lineCount <= edges) {
            /*
            check and process input data
            */
                inputProcess(str);
                lineCount++;
            }
            br.close();
        }catch (IOException e){
            e.printStackTrace();
        }
        int [] dist = new int[vertice];
        dijkstra(dist);
    }

}