Some 1×2 dominoes are placed on a plane. Each dominoe is placed either horizontally or vertically. It's guaranteed the dominoes in the same direction are not overlapped, but horizontal and vertical dominoes may overlap with each
other. You task is to remove some dominoes, so that the remaining dominoes do not overlap with each other. Now, tell me the maximum number of dominoes left on the board.

　　There are multiple input cases.
　　The first line of each case are 2 integers: n(1 <= n <= 1000), m(1 <= m <= 1000), indicating the number of horizontal and vertical dominoes.
Then n lines follow, each line contains 2 integers x (0 <= x <= 100) and y (0 <= y <= 100), indicating the position of a horizontal dominoe. The dominoe occupies the grids of (x, y) and (x + 1, y).
　　Then m lines follow, each line contains 2 integers x (0 <= x <= 100) and y (0 <= y <= 100), indicating the position of a horizontal dominoe. The dominoe occupies the grids of (x, y) and (x, y + 1).
　　Input ends with n = 0 and m = 0.

　　For each test case, output the maximum number of remaining dominoes in a line.

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

4
6

2013 Multi-University Training Contest 2

训练的时候想出了一个算法：找出各个由横竖牌交错连接起来的整体面积，最后的牌数等于各个(面积+1)/2相加。当时没从理论上证明。
后来别人总理论上证明了：把每个牌当做一个点，牌有重叠部分代表点之间有连线。那么这些连起来的点形成一条线，且相邻的点不能同时取，那么能取的点数（即牌数）是这个（线的点数+1）/2;

开始写的代码超时，是因为代码没处理好细节，导致无限循环，通过设置count记录循环的次数，证明了这一点。

#include<cstdio>
#include<cstring>
#include<vector>

using namespace std;

struct Node{
	int x,y;
}a[1100],b[1100];

bool vis[2][1100];

vector<int> son[2][1100];

int main()
{
	int n,m;
	int i,j;

	while(scanf("%d%d",&n,&m),n||m)
	{
		for(i=1;i<=n;i++)
		{
			scanf("%d%d",&a[i].x,&a[i].y);
			son[0][i].clear();
		}
		for(i=1;i<=m;i++)
		{
			scanf("%d%d",&b[i].x,&b[i].y);
			son[1][i].clear();
		}

		for(i=1;i<=n;i++)
		{
			for(j=1;j<=m;j++)
			{
				if(a[i].x==b[j].x && a[i].y==b[j].y || a[i].x+1==b[j].x && a[i].y==b[j].y
					|| a[i].x==b[j].x && a[i].y==b[j].y+1 || a[i].x+1==b[j].x&&a[i].y==b[j].y+1)
				{
					son[0][i].push_back(j);	son[1][j].push_back(i);
				}

			}
		}

		int sum=0,tmp,flag,d;
		int count;
		memset(vis,0,sizeof(vis));
		for(i=1;i<=n;i++)
		{
			if(!vis[0][i])
			{
				if(son[0][i].size()==0)
				{
					sum++;
					continue;
				}
				vis[0][i]=true;
				tmp=son[0][i][0];	flag=1;	d=2;
				vis[1][tmp]=1;
				count=1;
				while(son[flag][tmp].size()!=1)
				{
					if(!vis[(flag+1)%2][son[flag][tmp][0]])
						tmp=son[flag][tmp][0];
					else if(!vis[(flag+1)%2][son[flag][tmp][1]])
						tmp=son[flag][tmp][1];
					else
						break;
					flag=(flag+1)%2;
					vis[flag][tmp]=true;
					d++;
					count++;
					if(count>3000)
					{
						printf("Error\n");
						break;
					}
				}
				if(son[0][i].size()==2 && !vis[1][son[0][i][1]])
				{
					tmp=son[0][i][1];	flag=1;	d++;
					vis[1][tmp]=1;
					count=1;
					while(son[flag][tmp].size()!=1)
					{
						if(!vis[(flag+1)%2][son[flag][tmp][0]])
						tmp=son[flag][tmp][0];
						else if(!vis[(flag+1)%2][son[flag][tmp][1]])
							tmp=son[flag][tmp][1];
						else
							break;
						flag=(flag+1)%2;
						vis[flag][tmp]=true;
						d++;
						count++;
						if(count>3000)
						{
							printf("Error\n");
							break;
						}
					}
				}
				sum+=(d+1)/2;
			}
		}
		for(i=1;i<=m;i++)
		{
			if(!vis[1][i])
				sum++;
		}
		printf("%d\n",sum);
	}

	return 0;
}