Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Single Source Shortest Path II

For a given weighted graph $G = (V, E)$, find the shortest path from a source to each vertex. For each vertex $u$, print the total weight of edges on the shortest path from vertex $0$ to $u$.

Input

In the first line, an integer $n$ denoting the number of vertices in $G$ is given. In the following $n$ lines, adjacency lists for each vertex $u$ are respectively given in the following format:

$u$ $k$ $v_1$ $c_1$ $v_2$ $c_2$ ... $v_k$ $c_k$

Vertices in $G$ are named with IDs $0, 1, ..., n-1$. $u$ is ID of the target vertex and $k$ denotes its degree. $v_i (i = 1, 2, ... k)$ denote IDs of vertices adjacent to $u$ and $c_i$ denotes the weight of a directed edge connecting $u$ and $v_i$ (from $u$ to $v_i$).

Output

For each vertex, print its ID and the distance separated by a space character in a line respectively. Print in order of vertex IDs.

Constraints

$1 \leq n \leq 10,000$

$0 \leq c_i \leq 100,000$

$|E| < 500,000$

All vertices are reachable from vertex $0$

Sample Input 1

5
0 3 2 3 3 1 1 2
1 2 0 2 3 4
2 3 0 3 3 1 4 1
3 4 2 1 0 1 1 4 4 3
4 2 2 1 3 3

Sample Output 1

0 0
1 2
2 2
3 1
4 3

Reference

Introduction to Algorithms, Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. The MIT Press.

Solution in Ruby (judge verdict: Accepted)

module Color
  WHITE = 0
  GRAY = 1
  BLACK = 2
end

class MyNode
  attr_reader :v, :c
  def initialize(v, c)
    @v = v
    @c = c
  end
end

class PriorityQueue

  def initialize
    @arr = []
    @h = 0
  end

  def insert(node)
    @h += 1
    @arr[@h] = - 1.0/0
    heap_increase_key(@h, node)
    # puts "h : #{@h}"
  end

  def heap_increase_key(i, node)
    @arr[i] = node
    while i > 1 && @arr[parent(i)].c < @arr[i].c do
      @arr[i], @arr[parent(i)] = @arr[parent(i)], @arr[i]
      i = parent(i)
    end
  end

  def heap_extract_max()
    # puts "h : #{@h} extract"
    # puts "arr : #{@arr}"
    # puts "empty? : #{empty?}"
    if @h < 1
      raise "HEAP_UNDERFLOW"
    end
    max = @arr[1]
    @arr[1] = @arr.pop
    @h -= 1
    max_heapify(1)
    # puts "arr : #{@arr}"
    max
  end

  def parent(i)
    ( i / 2 ).ceil
  end

  def right(i)
    2 * i + 1
  end

  def left(i)
    2 * i
  end

  def max_heapify(i)
    l = left(i)
    r = right(i)
    h = @arr.size - 1

    # puts "i : #{i}, l : #{l}, r : #{r}, h : #{h} arr[r] : #{arr[r]}, arr : #{arr}"

    largest = nil
    if l <= h && @arr[l].c > @arr[i].c
      largest = l
    else
      largest = i
    end
    if r <= h && @arr[r].c > @arr[largest].c
      largest = r
    end

    if largest != i
      @arr[i], @arr[largest] = @arr[largest], @arr[i]
      max_heapify(largest)
    end
  end

  def empty?
    @h == 0
  end
end

def dijkstra(s)
  d = Array.new($n, Float::INFINITY)
  color = Array.new($n, Color::WHITE)
  d[s] = 0

  pq = PriorityQueue.new
  pq.insert(MyNode.new(0, 0))
  

  while !pq.empty?
    # puts d.join(' ')
    # puts pq
    
    node = pq.heap_extract_max
    u = node.v
    cost = node.c

    # puts $adj[u].join(' ')
    # puts "====="

    color[u] = Color::BLACK

    if d[u] < cost * -1
      next
    end

    $adj[u].each do | vc |
      v = vc[0]
      c = vc[1]
      # puts "vc: #{vc}, v: #{v}, c: #{c}"
      if color[v] == Color::BLACK
        next
      end
      if d[u] + c < d[v]
        d[v] = d[u] + c
        color[v] = Color::GRAY
        pq.insert(MyNode.new(v, d[v] * -1))
      end
    end
  end
  d
end

$n = gets.to_i
$adj = Array.new($n) { [] }
$n.times do |i|
  u, k, *arr = gets.split.map(&:to_i)
  arr.each_slice(2) do |v, c|
    $adj[u] << [v, c]
  end
end
# puts "====="
# $m.each do |k|
#   puts k.join(' ')
# end
# puts "====="

d = dijkstra(0)
d.each_with_index do | v, i |
  puts "#{i} #{v}"
end