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

切り取り線(Cutting)

JOI 君はペーパークラフトが趣味である．今日もJOI 君はペーパークラフトの作品を作ろうとしている．まず，JOI 君は設計図にしたがって1 枚の長方形の紙に $N$ 本の切り取り線を印刷した．各切り取り線は，紙の縦または横の辺に平行な線分である．

紙を切り出してできるすべての部分は作品の中で何らかの部品として用いられる．当然のことながら，
部品数の多い作品は製作が大変である．JOI 君は，すべての切り取り線にしたがって紙を切り出したとき，
紙がいくつの部分に分かれるかを知りたい．

課題

紙の大きさと，$N$ 本の切り取り線の情報が与えられる．これらの切り取り線にしたがって紙を切り分けたとき，紙がいくつの部分に分かれるかを求めるプログラムを作成せよ．

入力

標準入力から以下のデータを読み込め．

1 行目には，整数 $W, H, N$ が空白を区切りとして書かれている．$W$ は紙の横の辺の長さを，$H$ は紙の縦の辺の長さを，$N$ は切り取り線の本数をそれぞれ表す．紙の左下，右下，左上，右上を，それぞれ座標 $(0, 0), (W, 0), (0, H), (W, H)$ で表す．

続く $N$ 行のうちの $i$ 行目 $(1 \leq i \leq N)$ には，整数 $A_i, B_i, C_i, D_i (0 \leq A_i \leq C_i \leq W, 0 \leq B_i \leq D_i \leq H)$ が空白を区切りとして書かれている．これは $i$ 番目の切り取り線が$(A_i, B_i)$ と$(C_i, D_i)$ を結ぶ線分であることを表す．この線分は紙のいずれかの辺に平行な線分である．すなわち，$A_i = C_i$ と $B_i = D_i$ のうちのちょうど1 つが成り立つ．また，ある切り取り線と，それに平行な他の切り取り線が共有点を持つことはなく，ある切り取り線と，それに平行な紙の辺が共有点を持つこともない．

出力

標準出力に，紙がいくつの部分に分かれるかを表す整数を1 行で出力せよ．

制限

すべての入力データは以下の条件を満たす．

$ 1 \leq W \leq 1000000 000$

$ 1 \leq H \leq 1000000 000$

$ 1 \leq N \leq 100000$

入出力例

入力例 1

10 10 5
6 0 6 7
0 6 7 6
2 3 9 3
2 3 2 10
1 9 8 9

出力例 1

4

この入力の場合，切り取り線は下図のようになる．

よって，切り取り線によって紙は4 つの部分に分かれる．

入力例 2

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

出力例 2

5

この入力の場合，切り取り線は次ページの図のようになる．

よって，切り取り線によって紙は5 つの部分に分かれる．

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

Solution in Ruby (judge verdict: Runtime Error)

class Array
	def bsearch(l = 0, r = size - 1, &pred)
		if r - l < 100
			return (l..r).find{|j| pred[self[j]]}
		end

		c = (l + r) / 2 
		if pred[self[c]]
			bsearch(l, c-1, &pred) || c
		else
			bsearch(c+1, r, &pred)
		end
	end
end

class Line
	def initialize(*args)
		@x1, @y1, @x2, @y2 = args
	end
	attr_reader :x1, :y1, :x2, :y2
end

class IntervalTree
	def initialize(l, r)
		@l = l
		@r = r
		@c = (l + r) / 2
		@left_child = @right_child = nil
		@start_sorted = []
		@end_sorted = []
	end

	def add(l, r, x)
		if r < @c
			@left_child ||= self.class.new(l, @c - 1)
			@left_child.add(l, r, x)
		elsif @c < l
			@right_child ||= self.class.new(@c + 1, r)
			@right_child.add(l, r, x)
		else
			i = @start_sorted.bsearch{|p, q, _| p >= l} || @start_sorted.size
			@start_sorted.insert(i, [l, r, x])
			i = @end_sorted.bsearch{|p, q, _| q >= r} || @end_sorted.size
			@end_sorted.insert(i, [l, r, x])
		end
	end

	def query(x)
		if x < @c
			ans = @start_sorted.take_while{|l, r| l <= x} 
			ans += @left_child.query(x) if @left_child
			ans
		elsif x > @c
			ans = []
			ans += @right_child.query(x) if @right_child
			i = @end_sorted.bsearch{|l, r| x <= r}
			ans += @end_sorted[i..-1] if i
			ans
		else
			@start_sorted
		end
	end
end

class UnionFind
	def initialize
		@obj_to_node = {}
	end

	def add(obj)
		@obj_to_node[obj] ||= Node.new(obj)
	end

	def size(x = nil)
		x ? @obj_to_node[x].root.size : @obj_to_node.size
	end

	class Node
		def initialize(obj)
			@obj = obj
			@parent = self
			@size = 1
			@rank = 0
		end

		def root
			return self if @parent == self
			@parent = @parent.root
		end	

		attr_accessor :parent, :size, :rank
	end

	def union(x, y)
		u = v = nil
		if x.class == Node
			u = x.root
		else
			u = (@obj_to_node[x] ||= Node.new(x)).root
		end

		if y.class == Node
			v = y.root
		else
			v = (@obj_to_node[y] ||= Node.new(y)).root
		end

		return if u == v
		
		if u.rank > v.rank
			v.parent = u
			u.size += v.size
		elsif v.rank > u.rank
			u.parent = v
			v.size += u.size
		else
			u.parent = v
			v.size += u.size
			v.rank += 1
		end
	end

	def same?(x, y)
		return false unless u = @obj_to_node[x]
		return false unless v = @obj_to_node[y]
		u.root == v.root
	end

	def root_of(x)
		v = @obj_to_node[x]
		v ? v.root : nil
	end
end


uf = UnionFind.new

w, h, n = gets.split.map(&:to_i)
h_tree = IntervalTree.new(0, h)
h_line = {}

l1 = Line.new(0,0,w,0)
l2 = Line.new(0,h,w,h)

h_line[[0,w,0]] = l1
h_line[[0,w,h]] = l2

uf.union(l1, l2)

h_tree.add(0, w, 0)
h_tree.add(0, w, h)

v_lines = []

count = 1
n.times {|hoge|
	#p hoge
	x1, y1, x2, y2 = gets.split.map(&:to_i)

	if x1 == x2
		l = Line.new(x1, y1, x2, y2)
		v_lines << l
	end

	if y1 == y2
		l = Line.new(x1, y1, x2, y2)
		h_line[[x1, x2, y1]] = l
		uf.add(l)
		uf.union(l, l1) if x1 == 0 || x2 == w 
count += 1 if x1 == 0 && x2 == w
		h_tree.add(x1, x2, y1)
	end
}

v_lines.each_with_index{|l, i|
	#p i
	#break
	a = h_tree.query(l.x1).map{|arr| h_line[arr]}
	a = a.select{|line| l.y1 <= line.y1 && line.y2 <= l.y2}

	group_count = Hash.new(-1)
	a.each{|hl| group_count[uf.root_of(hl)] += 1}
	count += group_count.values.inject(0, :+)
	#p a.size
	#a.each_cons(2){|foo, bar| uf.union(foo, bar)}
	group_count.keys.each_cons(2){|foo, bar| uf.union(foo, bar)}
}

p count