The Happy Worm(poj1974)

The Happy Worm

Time Limit: 5000MS

Memory Limit: 131072K

Description

The Happy Worm lives in an m*n rectangular field. There are k stones placed in certain locations of the field. (Each square of the field is either empty, or contains a stone.) Whenever the worm sleeps, it lies either horizontally or vertically, and stretches so that its length increases as much as possible. The worm will not go in a square with a stone or out of the field. The happy worm can not be shorter than 2 squares. 

The question you are to answer is how many different positions this worm could be in while sleeping. 

Input

The first line of the input contains a single integer t (1 <= t <= 11), the number of test cases, followed by the input data for each test case. The first line of each test case contains three integers m, n, and k (1 <= m,n,k <= 131072). The input for this test case will be followed by k lines. Each line contains two integers which specify the row and column of a stone. No stone will be given twice.

Output

There should be one line per test case containing the number of positions the happy worm can be in.

Sample Input

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

Sample Output

9

#include<cstdio>
#include<cstdlib>
struct Lattice{
	int x, y;
}la[200000];
int cmpx(const void* c, const void* d){
	Lattice* a = (Lattice*)c;
	Lattice* b = (Lattice*)d;
	if (a->x == b->x) return a->y - b->y;
	else return a->x - b->x;
}
int cmpy(const void* c, const void* d){
	Lattice* a = (Lattice*)c;
	Lattice* b = (Lattice*)d;
	if (a->y == b->y) return a->x - b->x;
	else return a->y - b->y;
}
int main(){
	int T;
	scanf("%d", &T);
	while(T--){
		int m, n , k;
		scanf("%d%d%d", &m, &n, &k);
		for (int i = 0; i < k; ++i)
			scanf("%d%d", &la[i].x, &la[i].y);
		int po = 0;
		if (k == 0) po = m + n;
		else{
			qsort(la, k, sizeof(Lattice), cmpx);
			po += la[0].x - 1;
			if (la[0].y > 2) ++po;
			for (int i = 0; i < k - 1; ++i)
				if (la[i].x == la[i+1].x){
					if (la[i].y + 2 < la[i+1].y) ++po;
				}else{
					po += la[i+1].x - la[i].x - 1;
					if (la[i].y + 1 < n) ++po;
					if (la[i+1].y > 2) ++po;
				}
			if (la[k-1].y + 1 < n) ++po;
			po += m - la[k-1].x;
			qsort(la, k, sizeof(Lattice), cmpy);
			po += la[0].y - 1;
			if (la[0].x > 2) ++po;
			for (int i = 0; i < k - 1; ++i)
				if (la[i].y == la[i+1].y ){
					if (la[i].x + 2 < la[i+1].x) ++po;
				}else{
					po += la[i+1].y - la[i].y - 1;
					if (la[i].x + 1 < m) ++po;
					if (la[i+1].x > 2) ++po;
				}
			if (la[k-1].x + 1 < m) ++po;
			po += n - la[k-1].y;
		}
		printf("%d\n", po);
	}
	return 0;
}