Problem:
Problem D: Graph Construction

n 匹のうさぎがいて, 0 番からn − 1 番の番号がついた小屋に1 匹ずつ住んでいる.

あるとき, 秘密の組織によって地下通路の建設工事が行われる, という情報がうさぎたちのもとへ入った. 地下通路を使えば, うさぎたちは他のうさぎたちの小屋へ遊びに行けるようになって嬉しい.

通路は両方向に進むことができ, また通路同士は交わらない. 諸事情により, 一度建設された通路が破壊されてしまうこともある. 通路の建設や破壊の工事は1 本ずつ行われ, 各工事中はうさぎは自分の小屋に留まっているものとする.

うさぎたちは, 工事のいくつかの段階において, あるうさぎとあるうさぎが遊べるかどうかを事前に知りたい. うさぎたちは仲良しなので, 遊びに行くときに他のうさぎの小屋を自由に通ることができる. プログラミングが好きなうさぎたちは, 昔似たような問題を解いたので簡単だろうと思って挑戦し出したが, なかなか効率の良いプログラムが書けない. うさぎの代わりにこの問題を解け.

Input

入力の一行目にはn とk がスペース区切りで与えられる。2 ≤ n ≤ 40 000, 1 ≤ k ≤ 40 000

つづくk 行には工事情報と質問が合わせて, 時間順に与えられる.

“1 u v” — 小屋u とv を結ぶ通路が建設される. 小屋u とv を結ぶ通路がないときにのみ現れる.

“2 u v” — 小屋u とv を結ぶ通路が破壊される. 小屋u とv を結ぶ通路があるときにのみ現れる.

“3 u v” — 小屋u とv のうさぎが遊べるかどうか判定せよ.

0 ≤ u < v < n

Output

入力に現れる各質問について, 遊べるなら”YES”を, そうでないなら”NO”を1 行ずつ出力せよ.

Sample Input 1

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

Sample Output 1

YES
NO
YES

Solution in Ruby (judge verdict: Wrong Answer)

module Graphical
	require 'set'

	def reachable_from(s, max_depth = nil)
		reached = Set[s]
		queue = [s]
		depth = 0
		loop {
			break if max_depth && depth >= max_depth
			next_queue = []
			until queue.empty?
				u = queue.shift
				each_out_connection_of(u){|v, _|
					next if reached.include?(v)
					reached << v
					next_queue << v
				}
			end
			break if next_queue.empty?
			queue = next_queue
			depth += 1
		}
		return reached
	end

	def bfs(start, goal)
		reached = Set[start]
		queue = [start]
		loop {
			next_queue = []
			until queue.empty?
				u = queue.shift
				return true if u == goal
				u.edges.each{|e|
					v = e.opposite[u]
					next if reached.include?(v)
					reached << v
					next_queue << v
				}
			end
			break if next_queue.empty?
			queue = next_queue
		}
		false
	end
end

class Graph
	include Graphical

	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.edges << e
		v.edges << e
		e
	end
	
	def del_edge(e)
		u, v = e.opposite.keys
		u.del_edge(e)
		v.del_edge(e)
		e
	end

	class Node
		def initialize(property)
			@property = property
			@edges = Set.new
		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, :edges
	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
	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
end

n, m = gets.split.map &:to_i
g = Graph.new
nodes = (0..n-1).map{|i| g.add_node({:name => i}) }
edges = {}

b = Math.sqrt(m).ceil 

def g.each_out_connection_of(u)
	i = u.property[:name]
	super(u){|v, _|
		j = v.property[:name]
		yield(v, 1) unless $to_be_del[Set[i, j]]
	}
end


(1..m).each_slice(30*b){|a|
	#break if a[-1] > 1000	
	#p a

	$to_be_del = {}
	queries = a.map {	
		q, i, j = gets.split.map &:to_i
		$to_be_del[[i, j]] = 0 if q == 2
		[q, i, j]
	}

	rep = (1..n).map{ nil }
	(0..n-1).each{|i|
		next if rep[i]
		u = nodes[i]
		g.reachable_from(u).each{|v|
			rep[v.property[:name]] = i
		}
	}

	c_g = Graph.new
	c_nodes = (1..n).map{ c_g.add_node }
	$to_be_del.each_key{|i, j|
		u, v = rep[i], rep[j]
		c_g.add_edge(nodes[u], nodes[v])	
	}

	queries.each{|q, i, j|
		case q
		when 1
			e = g.add_edge(nodes[i], nodes[j])
			edges[i*n+j] = e
			c_g.add_edge(c_nodes[rep[i]], c_nodes[rep[j]])
		when 2
			e = edges[i*n+j]
			g.del_edge(e)
			edges.delete(i*n+j)
		when 3
			puts c_g.bfs(c_nodes[i], c_nodes[j]) ? 'YES' : 'NO'
		end
	}
}