Problem:
Problem C: Count the Regions There are a number of rectangles on the x-y plane. The four sides of the rectangles are parallel to either the x -axis or the y -axis, and all of the rectangles reside within a range specified later. There are no other constraints on the coordinates of the rectangles. The plane is partitioned into regions surrounded by the sides of one or more rectangles. In an example shown in Figure C.1, three rectangles overlap one another, and the plane is partitioned into eight regions. Rectangles may overlap in more complex ways. For example, two rectangles may have overlapped sides, they may share their corner points, and/or they may be nested. Figure C.2 illustrates such cases. Your job is to write a program that counts the number of the regions on the plane partitioned
by the rectangles. Input The input consists of multiple datasets. Each dataset is formatted as follows.  n  l 1  t 1  r 1  b 1  l 2  t 2  r 2  b 2 : l n  t n  r n  b n  A dataset starts with n (1 ≤ n ≤ 50), the number of rectangles on the plane. Each of the
following n lines describes a rectangle. The i -th line contains four integers, l i , t i , r i , and b i , which are the coordinates of the i -th rectangle; ( l i , t i ) gives the x-y coordinates of the top left corner, and ( r i , b i ) gives that of the bottom right corner of the rectangle (0 ≤ l i < r i ≤ 10 6 , 0 ≤ b i < t i ≤ 10 6 , for 1 ≤ i ≤ n ). The four integers are separated by a space. The input is terminated by a single zero. Output For each dataset, output a line containing the number of regions on the plane partitioned by the sides of the rectangles.   Figure C.1. Three rectangles partition the plane into eight regions. This corresponds to the first dataset of the sample input. The x - and y -axes are shown for illustration purposes only, and therefore they do not partition the plane.    Figure C.2. Rectangles overlapping in more complex ways. This corresponds to the
second dataset.  Sample Input 3
4 28 27 11
15 20 42 5
11 24 33 14
5
4 28 27 11
12 11 34 2
7 26 14 16
14 16 19 12
17 28 27 21
2
300000 1000000 600000 0
0 600000 1000000 300000
0 Output for the Sample Input 8
6
6

Solution (Python):
import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools

sys.setrecursionlimit(10**7)
inf = 10**20
eps = 1.0 / 10**13
mod = 10**9+7
dd = [(-1,0),(0,1),(1,0),(0,-1)]
ddn = [(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]

def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def pf(s): return print(s, flush=True)



class Ruiwa():
    def __init__(self, a):
        self.H = h = len(a)
        self.W = w = len(a[0])
        self.R = r = a
        for i in range(h):
            for j in range(1,w):
                r[i][j] += r[i][j-1]

        for i in range(1,h):
            for j in range(w):
                r[i][j] += r[i-1][j]

    def search(self, x1, y1, x2, y2):
        if x1 > x2 or y1 > y2:
            return 0

        r = self.R
        rr = r[y2][x2]
        if x1 > 0 and y1 > 0:
            return rr - r[y1-1][x2] - r[y2][x1-1] + r[y1-1][x1-1]
        if x1 > 0:
            rr -= r[y2][x1-1]
        if y1 > 0:
            rr -= r[y1-1][x2]

        return rr

def main():
    rr = []

    def f(n):
        a = [LI() for _ in range(n)]
        xs = set()
        ys = set()
        for l,t,r,b in a:
            xs.add(l)
            xs.add(r)
            ys.add(t)
            ys.add(b)
        xd = {}
        for x,i in zip(sorted(xs), range(len(xs))):
            xd[x] = i
        yd = {}
        for y,i in zip(sorted(ys), range(len(ys))):
            yd[y] = i
        z = []
        for l,t,r,b in a:
            z.append([xd[l],yd[t],xd[r],yd[b]])
        xx = len(xs) + 3
        yy = len(ys) + 3
        aa = [[0]*xx for _ in range(yy)]
        ii = [2**i for i in range(n)]
        for i in range(n):
            l,t,r,b = map(lambda x: x+1, z[i])
            aa[b][l] += ii[i]
            aa[t][l] -= ii[i]
            aa[b][r] -= ii[i]
            aa[t][r] += ii[i]
        rui = Ruiwa(aa)
        t = rui.R
        def _f(i,j,k):
            if i < 0 or i >= yy or j < 0 or j >= xx:
                return
            if t[i][j] != k:
                return
            t[i][j] = -1
            for di,dj in dd:
                _f(i+di,j+dj,k)
        r = 0
        for i in range(yy):
            for j in range(xx):
                if t[i][j] >= 0:
                    _f(i,j,t[i][j])
                    r += 1
        return r

    while True:
        n = I()
        if n == 0:
            break
        rr.append(f(n))

    return '\n'.join(map(str,rr))


print(main())

Solution (Python):


from collections import deque
import itertools as it
import sys

sys.setrecursionlimit(1000000)

while True:
    n = input()
    if n == 0:
        break
    
    lst = []
    x_lst = []
    y_lst = []

    for loop in range(n):
        l, t, r, b = map(int, raw_input().split())
        lst.append((l, t, r, b))
        x_lst += [l, r]
        y_lst += [t, b]

    x_lst = sorted(list(set(x_lst)))
    y_lst = sorted(list(set(y_lst)))

    mx = {}
    my = {}

    for i in range(len(x_lst)):
        mx[x_lst[i]] = 2 * i + 1

    for i in range(len(y_lst)):
        my[y_lst[i]] = 2 * i + 1

    wall = {}

    def func(x, y):
        if (x, y) in wall:
            return
        if x < 0 or y < 0 or x > 5 * n or y > 5 * n:
            return
        wall[(x, y)] = 1
        func(x - 1, y)
        func(x + 1, y)
        func(x, y - 1)
        func(x, y + 1)

    for sq in lst:
        sx = mx[sq[0]]
        gx = mx[sq[2]]
        sy = my[sq[3]]
        gy = my[sq[1]]
        for x in range(sx, gx + 1):
            wall[(x, sy)] = 1
            wall[(x, gy)] = 1
        for y in range(sy, gy + 1):
            wall[(sx, y)] = 1
            wall[(gx, y)] = 1

    ans = 0

    for y in range(5 * n):
        for x in range(5 * n):
            if not (x, y) in wall:
                ans += 1
                func(x, y)

    print ans

Solution (Python):

import sys
sys.setrecursionlimit(1000000)

def check(i,j):
    global n
    global m
    if m[i][j]==0:
        m[i][j]=-1
        if i+1<n*4+2:
            check(i+1,j)
        if i-1>=0:
            check(i-1,j)
        if j+1<n*4+2:
            check(i,j+1)
        if j-1>=0:
            check(i,j-1)

while True:
    n=int(input())
    if n==0:
        break
    points=[]
    plane=[[-1,-1,-1,-1] for i in range(n)]
    dic={}
    for i in range(n):
        a,b,x,y=map(int,input().split())
        dic[(a,b,i)]=0
        dic[(x,y,i)]=1
        points.append((a,b,i))
        points.append((x,y,i))
    points=sorted(points)
    p=0
    for i in range(len(points)):
        if dic[points[i]]==0:
            plane[points[i][2]][0]=p
        else:
            plane[points[i][2]][2]=p
        if i+1<len(points) and points[i][0]==points[i+1][0]:
            pass
        else:
            p+=1
    points=sorted(points,key=lambda q:q[1])
    p=0
    for i in range(len(points)):
        if dic[points[i]]==0:
            plane[points[i][2]][1]=p
        else:
            plane[points[i][2]][3]=p
        if i+1<len(points) and points[i][1]==points[i+1][1]:
            pass
        else:
            p+=1
    m=[[0 for i in range(n*4+2)]for i in range(n*4+2)]
    for p in plane:
        for j in range((p[1]-p[3])*2+1):
            m[p[0]*2+1][p[3]*2+j+1]=1
            m[p[2]*2+1][p[3]*2+j+1]=1
        for j in range((p[2]-p[0])*2+1):
            m[p[0]*2+j+1][p[3]*2+1]=1
            m[p[0]*2+j+1][p[1]*2+1]=1
    ans=0
    for i in range(n*4+2):
        for j in range(n*4+2):
            if m[i][j]==0:
                ans+=1
                check(i,j)
    print(ans)