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.
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;
}