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


import collection.mutable.ArrayBuffer
import scala.reflect.ClassTag
import scala.language.implicitConversions

trait Graph { 
    case class Edge[T:Numeric](from : Int, to : Int, cost : T)

    class Edges[T:Numeric](val data : ArrayBuffer[Edge[T]]) {
        def size = data.size
    }
    object Edges {
        def apply[T:Numeric](xs : Edge[T]*) = new Edges(ArrayBuffer(xs:_*))
        implicit def toUnderLying[T](x:Edges[T]) = x.data
    }

    class WeightedGraph[T:Numeric](val size : Int, val data : Array[Edges[T]]) {
        def this(size : Int) = this(size, Array.fill(size)(Edges()))
    }
    object WeightedGraph {
        def apply[T:Numeric](size : Int) = new WeightedGraph[T](size)
        implicit def toUnderLying[T](x:WeightedGraph[T]) = x.data
    }

    class UnWeightedGraph[T:Numeric](val size : Int, val data: Array[ArrayBuffer[T]]) {
        def this(size : Int) = this(size, Array.fill(size)(ArrayBuffer[T]()))
    }
    object UnWeightedGraph {
        def apply[T:Numeric](size : Int) = new UnWeightedGraph[T](size)
        implicit def toUnderLying[T](x:UnWeightedGraph[T]) = x.data
    }
   
    class Matrix[T:Numeric:ClassTag](val row : Int, val col : Int, val data : Array[Array[T]]) {
        def this(row : Int, col : Int) = this(row, col, Array.fill(row, col)(implicitly[Numeric[T]].zero))
        def this(size : Int) = this(size, size)
    }
    object Matrix {
        implicit def toUnderLying[T](x:Matrix[T]) = x.data
    }
}
import scala.collection.mutable.PriorityQueue

object Dijkstra extends Graph {
    def dijkstra[T:ClassTag](g : WeightedGraph[T], s : Int, INF : T)(implicit num : Numeric[T]) : Array[T] = {
        import num._
        val dist = Array.fill(g.size)(INF)
        dist(s) = zero
        // (shortest path candidate, vertex)
        val que = PriorityQueue()(Ordering.Tuple2[T, Int].reverse)
        que += ((zero, s))
        while(!que.isEmpty) {
            val (d, v) = que.dequeue
            if (dist(v) >= d) {
                for (e <- g(v)) {
                    val cost = dist(v) + e.cost
                    if (dist(e.to) > cost) {
                        dist(e.to) = cost
                        que += ((cost, e.to))
                    }
                }
            }
        }
        dist
    }
}

// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_1_A
import Dijkstra._

object Main {
    def main(args: Array[String]) = {
        val sc = new java.util.Scanner(System.in)
        val V, E, r = sc.nextInt
        val edges = WeightedGraph[Int](V)
        for (_ <- 1 to E) {
            val s, t, c = sc.nextInt
            edges(s) += Edge(s, t, c)
        }
        val res = dijkstra(edges, r, Int.MaxValue)
        if (res.isEmpty) println("NEGATIVE CYCLE")
        else {
            for (d <- res)
            if (d == Int.MaxValue) println("INF")
            else println(d)
        }
    }
}