Problem:
問題 5:　タクシー (Taxis)

問題

IOI 国は町 1 から町 N までの N 個の町からなり，町と町とは道路で結ばれている．IOI 国には K 本の道路があり，すべての道路は異なる 2 つの町を結んでいる．車は道路を双方向に自由に移動できるが，道路以外を通ってある町から別の町に行くことはできない．

IOI 国の町 1 に住む JOI 君は，町 N に住む祖母の家までタクシーで行くことにした．IOI 国にはタクシー会社 1 からタクシー会社 N までの N 個のタクシー会社がある．IOI 国のタクシー会社には次のような少々特殊な規則がある．

タクシー会社 i のタクシーには，町 i でのみ乗車できる．

タクシー会社 i のタクシーの運賃は，利用した距離によらず Ci である．

タクシー会社 i のタクシーは，乗車してから連続して最大 Ri 本の道路しか通ることができない．

たとえば R1 = 2 の場合，町 1 からタクシー会社 1 のタクシーに乗車すると，最大 2 本の道路しか通ることができないため，道路を 3 本以上通るためには途中の町でタクシーを乗り換える必要がある．

JOI 君は町以外の地点でタクシーに乗ったりタクシーから降りたりすることはできない．また，タクシー以外の移動手段を用いることもできない．JOI 君が町 N に到達するために必要な運賃の合計の最小値を求めるプログラムを作成せよ．

入力

入力は 1 + N + K 行からなる．

1 行目には，2 つの整数 N, K (2 ≤ N ≤ 5000, N - 1 ≤ K ≤ 10000) が空白を区切りとして書かれている．これは，IOI 国が N 個の町からなることと，IOI 国の道路の本数が K 本であることを表す．

続く N 行のうちの i 行目 (1 ≤ i ≤ N) には，2 つの整数 Ci, Ri (1 ≤ Ci ≤ 10000, 1 ≤ Ri ≤ N) が空白を区切りとして書かれている．これは，タクシー会社 i のタクシーの運賃が Ci で，乗車してから連続して最大 Ri 本の道路しか通ることができないことを表す．

続く K 行のうちの j 行目 (1 ≤ j ≤ K) には，異なる 2 つの整数 Aj, Bj (1 ≤ Aj ＜ Bj ≤ N) が空白を区切りとして書かれている．これは，町 Aj と町 Bj との間に道路が存在することを表す．同じ (Aj, Bj) の組が 2 回以上書かれていることはない．

与えられる入力データにおいては，どの町から別のどの町へもタクシーを乗り継いで行くことができることが保証されている．

出力

JOI 君が町 1 から町 N まで行くのに必要な運賃の合計の最小値を表す整数を 1 行で出力せよ．

入出力例

入力例

6 6
400 2
200 1
600 3
1000 1
300 5
700 4
1 2
2 3
3 6
4 6
1 5
2 4

出力例

700

上の入出力例は，以下の図に対応している．円は町を，線は道路を表す．

この入出力例でJOI 君が最小の運賃で町 6 に到達するには，以下のようにする．

町 1 からタクシーに乗って町 5 に行く． (運賃 400)

町 5 からタクシーに乗って町 6 に行く． (運賃 300)

JOI 君がこのようなルートを通った場合の運賃の合計は 400 + 300 = 700 であるので，700 を出力する．

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。

Solution in Ruby (judge verdict: Runtime Error)

module Graph
	require 'set'
	def add_node(label = nil)
		Node.new(label)
	end

	def add_edge(u, v, label = nil)
		e = Edge.new(u, v, label)
		u.outgoings << e
		v.incomings << e
		e
	end

	def del_edge(e)
		u, v = e.from, e.to
		u.outgoings.delete(e)
		v.incomings.delete(e)
		e
	end
	
	class Node
		def initialize(label)
			@label = label
			@outgoings = Set.new
			@incomings = Set.new
		end

		def to_nodes
			@outgoings.map(&:to)
		end

		def from_nodes
			@incomings.map(&:from)
		end


		def to_s
			@label
		end
		
		attr_accessor :outgoings, :incomings
		attr_reader :label
	end

	class Edge
		def initialize(u, v, label = nil)
			@from = u	
			@to = v
			@label = label
		end
		attr_reader :from, :to, :label
	end

	def until_depth(d, start)
		reached = Set[start]
		current_layer = [start]
		
		loop {
			next_layer = []
			current_layer.each{|u|
				u.to_nodes.each{|v|
					next if reached.include?(v)
					reached << v
					next_layer << v
				}
			}	
			d -= 1
			break if d == 0 || next_layer.empty?
			current_layer = next_layer
		}

		reached.to_a
	end
end

extend Graph

n, k = gets.split.map &:to_i
orig_nodes = (0..n-1).map{|i|
	add_node([i] + gets.split.map(&:to_i)) 
}

k.times {
	i, j = gets.split.map &:to_i
	u = orig_nodes[i-1]
	v = orig_nodes[j-1]
	add_edge(u, v)
	add_edge(v, u)
}


dist = (1..n).map{ Float::INFINITY }
dist[0] = 0
unreached = (0..n-1).to_a

loop.with_index {|_, itr|
	i = unreached.min_by{|i| dist[i]}
	#p [itr, i]
	break if i == n-1
	unreached.delete(i)
	u = orig_nodes[i]
	_, c, r = u.label
	until_depth(r, u).each{|v|
		j, _, _ = v.label
		d = dist[i] + c
		dist[j] = d if d < dist[j]
	}
}
p dist[n-1]