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: Wrong Answer)

import java.util.*;

class Main {
  final static int INF = 99999999;
  static int[][] adjArr;
  static int v;
  static int[] shortDist;
  static boolean[] visited;

  public static void main(String[] args){
    Scanner scan = new Scanner(System.in);
    v = scan.nextInt();
    int e = scan.nextInt();
    int s = scan.nextInt();

    adjArr = new int[v][v];
    shortDist = new int[v];
    visited = new boolean[v];

    Arrays.fill(shortDist, INF);
    Arrays.fill(visited, false);
    for(int[] i : adjArr) Arrays.fill(i, -1);

    int start;
    int end;
    int weight;
    for(int i = 0 ; i < e; i++) {
      start = scan.nextInt();
      end = scan.nextInt();
      weight = scan.nextInt();
      adjArr[start][end] = weight;
    }
    shortDist[s] = 0;


    /*for(int i = 0 ; i < v ; i++) {
      for(int j = 0 ; j < v ; j++) {
        System.out.print(adjArr[i][j] + " ");
      }
      System.out.println();
    }
    System.out.println("------------------");*/

    dijkstra();

    for(int i : shortDist) {
      if(i == INF) {
        System.out.println("INF");
      } else System.out.println(i);
    }
  }

  static void dijkstra() {
    while(true) {
      int u = getMin();
      if(u == -1) {
        break;
      }
      if(shortDist[u] == INF) {
        break;
      }
      visited[u] = true;
      for(int i = 0 ; i < v ; i++) {
        if(adjArr[u][i] >= 0) {
          int neighbor = i;
          int wei = adjArr[u][i];
          int newL = shortDist[u] + wei;
          if(newL < shortDist[neighbor]) {
            shortDist[neighbor] = newL;
          }
        }
      }
    }
  }

  // startから最小の距離の頂点取得
  static int getMin() {
    int tmp = INF;
    for(int i = 0 ; i < v ; i++) {
      if(visited[i] == false && shortDist[i] < tmp) {
        tmp = i;
      }
    }
    if(tmp == INF) {
      tmp = -1;
    }
    return tmp;
  }

}