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

use std::cmp;
use std::collections::HashMap;
use std::io::*;
use std::str::FromStr;
use std::string::String;

const MAX: isize = 2147483647;

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();

    token.parse().ok().expect("failed to parse token")
}

fn dijkstra(s: usize, n: usize, g: &Vec<Vec<(usize, isize)>>) -> Vec<isize> {
    let mut d: Vec<isize> = vec![MAX; n];
    d[s] = 0;
    let mut pq = std::collections::BinaryHeap::<(isize, usize)>::new();
    pq.push((d[s]*(-1), s));

    while !pq.is_empty() {
        let (mut tmpd, now): (isize, usize) = pq.pop().unwrap();
        if d[now] < tmpd {continue;}
        for &(to, cost) in &g[now] {
            if d[to] > d[now] + cost {
                d[to] = d[now] + cost;
                pq.push((d[to]*(-1), to));
            }
        }
    }
    d
}


fn main() {
    let (n, m, s): (usize, usize, usize) = (read(), read(), read());
    let mut g: Vec<Vec<(usize, isize)>> = Vec::new();
    //g.resize(5, Vec::new()); //g = [[], [], [], [], []];
    //println!{"{:?}", g};
    g.resize(n, Vec::new());
    for i in 0..m {
        let (u, v, c): (usize, usize, isize) = (read(), read(), read());
        //let (mut u, mut v, c): (usize, usize, usize) = (read(), read(), read());
        g[u].push((v, c));
    }
    //println!{"{:?}", g};
    let dist: Vec<isize> = dijkstra(s, n, &g);
    //println!{"{:?}", dist};
    for d in dist {
        if d == MAX {
            println!{"INF"};
        }
        else {
            println!{"{}", d};
        }
    }
}