class Graph
  attr_accessor :node
  def initialize(n=nil)
    @node = Array.new(n){Node.new}
  end
  def print
    @node.size.times{|i|
      puts "#{i} #{node[i].cost}"
    }
  end
end

class Node
  attr_accessor :edges_to, :edges_cost, :done, :cost
  def initialize
    @edges_to = []
    @edges_cost = []
    @done = false
    @cost = 1.0 / 0.0
  end
  def >(other)
    return self.cost < other.cost ? true : false
  end
  def <(other)
    return self.cost > other.cost ? false : true
  end
end


class Heep
  def initialize
    @node = []
  end
  def insert(num)
    i = @node.size
    @node[i] = num
    p = (i+1)/2-1
    while i > 0 && @node[p] < @node[i]
      @node[i], @node[p] = @node[p], @node[i]
      i = p
      p = (i+1)/2-1
    end
  end
  def extract
    ret = @node[0]
    if @node.size > 1
      @node[0] = @node.pop()
      maxHeapify(0)
    else
      @node = []
    end
    return ret
  end
  def maxHeapify(i)
    h = @node.size
    largest = i
    l = 2 * i + 1
    largest = l if l < h && @node[l] > @node[largest]
    r = 2 * i + 2
    largest = r if r < h && @node[r] > @node[largest]
    if largest != i then
      @node[i], @node[largest] = @node[largest], @node[i]
      maxHeapify(largest)
    end
  end
  def size
    return @node.size
  end
  def contain(node)
    if @node.index(node) == nil
      return false
    else
      return true
    end
  end
end

n = gets.to_i
graph = Graph.new(n)

n.times{
  u, k, *vc = gets.split.map(&:to_i)
  k.times{|i|
    graph.node[u].edges_to << vc[2*i]
    graph.node[u].edges_cost << vc[2*i+1]
  }
}
q = Heep.new
graph.node[0].cost = 0
q.insert(graph.node[0])

loop do
  break if q.size == 0
  doneNode = q.extract
  doneNode.done = true
  doneNode.edges_to.size.times{|i|
    to = doneNode.edges_to[i]
    cost = doneNode.cost + doneNode.edges_cost[i]
    if cost < graph.node[to].cost then
      graph.node[to].cost = cost
      q.insert(graph.node[to])
    end
  }
end

graph.print