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 Go (judge verdict: Time Limit Exceeded)

package main

import (
	"container/heap"
	"fmt"
)

const INF = 999999999999999999

type node struct {
	me    int
	total int64
	index int
	done  bool
}

func (pq PriorityQueue) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
	pq[i].index = i
	pq[j].index = j
}

type PriorityQueue []*node

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool {
	return pq[i].total <= pq[j].total
}

func (pq *PriorityQueue) Push(x interface{}) {
	item := x.(*node)
	item.index = len(*pq)
	*pq = append(*pq, item)
}

func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	item.index = -1
	*pq = old[0 : n-1]
	return item
}

type edge struct {
	to   int
	cost int64
}

func main() {
	var V, E, r int
	fmt.Scanf("%d %d %d", &V, &E, &r)

	edges := make([][]*edge, V)
	nodes := make([]*node, V)
	queue := make(PriorityQueue, 0, V)

	for i := 0; i < E; i++ {
		var s, t int
		var cost int64
		n, _ := fmt.Scanf("%d %d %d", &s, &t, &cost)
		if n != 3 {
			panic(fmt.Sprintf("scaned string want 3 but %d", n))
		}
		edges[s] = append(edges[s], &edge{to: t, cost: cost})

	}

	for i := 0; i < V; i++ {
		if r == i {
			nodes[i] = &node{me: i, total: 0}
			heap.Push(&queue, nodes[i])
		} else {
			nodes[i] = &node{me: i, total: INF}

		}
	}

	for queue.Len() > 0 {

		node := heap.Pop(&queue).(*node)
		if node.done {
			continue
		}
		node.done = true

		for _, edge := range edges[node.me] {
			alt := edge.cost + node.total

			if alt < nodes[edge.to].total {
				nodes[edge.to].total = alt

			}

			heap.Push(&queue, nodes[edge.to])

		}

	}

	for _, node := range nodes {
		if node.total >= INF {
			fmt.Printf("INF\n")
		} else {
			fmt.Printf("%d\n", node.total)
		}
	}

}