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 Haskell (judge verdict: Memory Limit Exceeded)

{-# LANGUAGE ViewPatterns, BangPatterns #-}
import Control.Monad
import Control.Applicative
import Data.List
import Data.Int
import qualified Data.Set as Set
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM

type Graph = V.Vector (V.Vector Edge)
type Edge = (Int32, Int)

inf :: Int32
inf = maxBound `div` 2

dijkstra :: Graph -> Int -> V.Vector Int32
dijkstra gr start = V.create $ do
  let n = V.length gr
  res <- VM.replicate n inf
  VM.write res start 0
  let go (Set.minView -> Just ((!d, !v), !q)) = do
        cur <- VM.read res v
        if cur < d
          then go q
          else do
            adds <- flip V.filterM (gr V.! v) $ \(!cost, !u) -> do
              old <- VM.read res u
              if old <= d + cost
                then return False
                else do
                  VM.write res u $! d + cost
                  return True
            nexts <- flip (`V.foldM` q) adds $ \(!pq) (_, !u) -> do
              dist <- VM.read res u
              return $! Set.insert (dist, u) pq
            go nexts
      go _ = return ()
  go $ Set.singleton (0, start)
  return res

splitRead :: Read a => IO [a]
splitRead = map read . words <$> getLine

readEdge :: IO (Int, Edge)
readEdge = do
  [s, t, d] <- words <$> getLine
  return (read s, (read d, read t))

showDist :: Int32 -> String
showDist d
  | d == inf = "INF"
  | otherwise = show d

main :: IO ()
main = do
  [v, e, r] <- splitRead
  es <- replicateM e readEdge
  let graph = V.map V.fromList $ V.accum (flip (:)) (V.replicate v []) es
      dists = dijkstra graph r
  V.mapM_ (putStrLn . showDist) dists