Problem:
問題文

ハコの魔女 H.N.ELLY はとある動画サイトの熱狂的なファンである．ハコの魔女の強さはその時々のその動画サイトからの転送速度に応じて変化するのではないかと美樹さやかは考えた．そこで動画サイトからハコの魔女の持つコンピュータまでの過去の転送速度 (=単位時間あたりのデータの転送量) を調べたい．

初期のインターネットのネットワークの構造とそれ以降のネットワークの構造の変化を表すクエリが与えられるので，各変化について変化した直後の動画サイトからハコの魔女の持つコンピュータまでの転送速度を求めよ．

インターネットは複数の転送装置からなるものと見なし，各々をつなぐ回線は双方向に情報を送ることができ，その転送速度の最大は 1 であるとする．また，ネットワークは常に動画サイトからハコの魔女へ送られるデータの転送速度を最大化するように運ぶものとする．

入力形式

入力は以下の形式で与えられる．

N\ E\ Q\\
F_1\ T_1\\
F_2\ T_2\\
…\\
F_E\ T_E\\
M_1\ A_1\ B_1\\
M_2\ A_2\ B_2\\
...\\
M_Q\ A_Q\ B_Q\\

N は動画サイトとハコの魔女の持つコンピュータを含めた転送装置の数である．番号が 1 である転送装置は動画サイトであり，番号が N である転送装置はハコの魔女の持つコンピュータである．E は初期状態で接続されている転送装置の組み合わせの数であり，Q はインターネットが変化した回数である．初期のインターネットは F_i と T_i が転送速度 1 で双方向に接続されていることを表す．

ネットワークの変化は時系列順に与えられ，j 番目の変化は M_j が 1 であれば A_j,\ B_j 間がつながれたことを表し，M_j が 2 であれば A_j,\ B_j 間の接続が切れたことを表す．

出力形式

各変化の直後における，動画サイトからハコの魔女の持つコンピュータまでの転送速度を出力せよ．

制約

2 \leq N \leq 500

0 \leq E \leq 20,000

1 \leq Q \leq 1,000

1 \leq F_i \leq N,\ 1 \leq T_i \leq N,\ F_i \neq T_i \ (1 \leq i \leq E)

すべての \{F_i, T_i\} のペアは異なる．

1 \leq M_j \leq 2,\ 1 \leq A_j \leq N\ ,\ 1 \leq B_j \leq N\ ,\ A_j \neq B_j (1 \leq j \leq Q)

ネットワークのどの段階においても次のことが成り立つ : どの 2 つの転送装置の間も高々 1 つの回線でしか繋がれていない．

2 つの転送装置の間が既に繋がれている状態でそれらの間を接続するようなクエリが来たり，2 つの転送装置の間が回線で繋がれていない状態でそれらの間の接続を切るようなクエリが来ることはない．

入出力例

入力例 1

2 1 2
1 2
2 1 2
1 2 1

出力例1

0
1

最初の変化の後，ハコの魔女のコンピュータと動画サイトは繋がらなくなっているので転送速度は 0 である．

2 度目の変化の後は両者は直接繋がっており，転送速度は 1 になる．

入力例 2

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

出力例 2

0
1
2
1

入力例 3

6 4 8
1 2
1 3
4 6
5 6
1 2 4
1 3 5
1 2 5
1 3 4
2 2 4
2 3 5
1 2 4
2 2 1

出力例 3

1
2
2
2
2
2
2
1

入力例 4

12 38 6
1 2
1 3
1 4
1 5
2 3
2 4
2 5
2 6
2 7
2 8
2 12
3 4
3 5
3 6
3 7
3 8
4 5
4 6
4 7
4 8
5 6
5 7
5 8
6 7
6 8
6 9
6 10
6 12
7 8
7 9
7 10
8 9
8 10
9 10
9 11
9 12
10 11
11 12
2 6 12
2 9 12
1 9 12
1 6 12
2 6 12
1 6 12

出力例 4

3
2
3
4
3
4

Problem Setter: Flat35

Solution in Ruby (judge verdict: Wrong Answer)

require 'set'

class Graph
	def initialize(*options)
		@options = Set[*options]
	end

	def add_node(property = {})
		Node.new(property)
	end

	def add_edge(u, v, property = {})
		e = Edge.new(u, v, property)
		u.add_edge(e)
		v.add_edge(e)
		e
	end
	
	def del_edge(e)
		u, v = e.opposite.keys
		u.del_edge(e)
		v.del_edge(e)
	end

	class Node
		def initialize(property)
			@property = property
			@edges = Set.new
		end

		def add_edge(e)
			@edges << e
		end

		def del_edge(e)
			@edges.delete(e)
		end

		def to_s
			@property[:name] || super
		end

		def each_edge
			@edges.each{|e| 
				yield e
			}
		end

		attr_reader :property
	end

	class Edge
		def initialize(u, v, property)
			@opposite = {u => v, v => u}
			@property = property
		end
		attr_reader :opposite, :property

		def to_s
			@property[:name] || super
		end

		def length
			@property[:length] || 1
		end

		def actual_capacity(from)
			v = @opposite[from]
			cap = @property[:capacity]
			flow = @property[:flow]
			to = @property[:flow_to]
			to == v ? cap - flow : cap + flow
		end
	end

	def each_out_connection_of(u)
		u.each_edge{|e|
			yield(e.opposite[u], e.length)
		}
	end

	alias :each_in_connection_of :each_out_connection_of

	def get_augmenting_path(s, t)
		reached = Set[s]
		queue = [s]
		comming_edge = {}
		until queue.empty?
			u = queue.shift
			u.each_edge do |e|	
				v = e.opposite[u]
				next if reached.include?(v)
				next if e.actual_capacity(u) <= 0

				reached << v
				comming_edge[v] = e
				queue << v

				if v == t
					queue = []
					break
				end
			end	
		end

		if comming_edge[t]
			path = [t]
			v = t
			until path[-1] == s
				e = comming_edge[v]
				u = e.opposite[v]
				path << e
				path << u
				v = u
			end
			return path.reverse
		end

		return nil
	end
end

def add_flow(df, path)
	path.each_slice(2) do |u, e|
		break if !e
		v = e.opposite[u]

		cap = e.property[:capacity]
		flow = e.property[:flow]
		to = e.property[:flow_to]

		if to == v 
			e.property[:flow] += df
		elsif flow >= df
			e.property[:flow] -= df
		else
			e.property[:flow_to] = v
			e.property[:flow] = df - flow
		end
	end
end

n, m, q = gets.split.map(&:to_i)	
g = Graph.new
nodes = (0..n).map { g.add_node }
edges = {}

m.times do
	i, j = gets.split.map(&:to_i)
	i, j = j, i if j < i
	e = g.add_edge(nodes[i], nodes[j], {:capacity => 1, :flow => 0, :flow_to => nodes[j]})
	edges[[i, j]] = e
end

flow = 0
paths = []
loop do
	path = g.get_augmenting_path(nodes[1], nodes[n])
	break if !path
	add_flow(1, path)
	flow += 1
	paths << path
end

q.times do
	command, i, j = gets.split.map(&:to_i)
	i, j = j, i if j < i
	if command == 1
		e = g.add_edge(nodes[i], nodes[j], {:capacity => 1, :flow => 0, :flow_to => nodes[j]})
		edges[[i, j]] = e
	else
		e = edges[[i, j]]
		g.del_edge(e)
		edges.delete([i, j])

		if (e.property[:flow] || 0) != 0
			nodes[i]
			v = e.property[:flow_to]

			catch(:exit) do
				paths.each do |path|
					path[1..-1].each_slice(2) do |f, u|
						if f == e && u == v
							add_flow(1, path.reverse)
							paths.delete(path)
							throw :exit
						end
					end
				end
			end

			flow -= 1
		end
	end

	if path = g.get_augmenting_path(nodes[1], nodes[n])
		add_flow(1, path)
		flow += 1
		paths << path
	end

	p flow
end