Coconuts HDU - 5925 二维离散化 自闭了

TanBig, a friend of Mr. Frog, likes eating very much, so he always has dreams about eating. One day, TanBig dreams of a field of coconuts, and the field looks like a large chessboard which has R rows and C columns. In every cell of the field, there is one coconut. Unfortunately, some of the coconuts have gone bad. For sake of his health, TanBig will eat the coconuts following the rule that he can only eat good coconuts and can only eat a connected component of good coconuts one time(you can consider the bad coconuts as barriers, and the good coconuts are 4-connected, which means one coconut in cell (x, y) is connected to (x - 1, y), (x + 1, y), (x, y + 1), (x, y - 1).

Now TanBig wants to know how many times he needs to eat all the good coconuts in the field, and how many coconuts he would eat each time(the area of each 4-connected component).

InputThe first line contains apositiveinteger T(T≤10T≤10) which denotes the test cases. T test cases begin from the second line. In every test case, the first line contains two integers R and C, 0<R,C≤1090<R,C≤109 the second line contains an integer n, the number of bad coconuts, 0≤n≤2000≤n≤200 from the third line, there comes n lines, each line contains two integers, xixi and yiyi, which means in cell(xi,yixi,yi), there is a bad coconut.

It is guaranteed that in the input data, the first row and the last row will not have bad coconuts at the same time, the first column and the last column will not have bad coconuts at the same time. 
OutputFor each test case, output "Case #x:" in the first line, where x denotes the number of test case, one integer k in the second line, denoting the number of times TanBig needs, in the third line, k integers denoting the number of coconuts he would eat each time, you should output them in increasing order.Sample Input

2

3 3
2
1 2
2 1

3 3
1
2 2

Sample Output

Case #1:
2
1 6
Case #2:
1
8
题意

青蛙先生的朋友TanBig非常喜欢吃东西，所以他总是喜欢吃东西。

有一天，TanBig梦想着一片椰子，这个领域看起来像一个有R行和C列的大棋盘。

在田地的每个细胞中，都有一个椰子。 不幸的是，一些椰子变质了。 为了他的健康，

TanBig将按照他只能吃好椰子的规则来吃椰子，并且一次只能吃好椰子的连接成分

（你可以认为坏椰子是障碍，而好的椰子是4- 连接，这意味着单元格（x，y）

中的一个椰子连接到（x-1，y），（x + 1，y），（x，y + 1），（x，y-1）。

现在TanBig想知道他需要多少次吃掉田里所有好吃的椰子，以及每次吃多少椰子（每个4个连接组件的面积）。

其实就是让你求出每一个联通快的大小
因为 R C <= 1e9  所以必须离散化

自闭拉 自闭拉  完全不会啊
只能看题解为生  题目补不完了

二维离散化一下 因为点最多有是一个300*300的矩阵
离散化后用一个cntx，cnty，分别记录每一个格子压缩前的面积
然后就是最裸的DFS计算联通快就行了

注意一下最后的答案要从小到大输出

 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <cmath>
 #include <algorithm>
 #include <set>
 #include <iostream>
 #include <map>
 #include <stack>
 #include <string>
 #include <vector>
 #define  pi acos(-1.0)
 #define  eps 1e-6
 #define  fi first
 #define  se second
 #define  lson l,m,rt<<1
 #define  rson m+1,r,rt<<1|1
 #define  bug         printf("******\n")
 #define  mem(a,b)    memset(a,b,sizeof(a))
 #define  fuck(x)     cout<<"["<<x<<"]"<<endl
 #define  f(a)        a*a
 #define  sf(n)       scanf("%d", &n)
 #define  sff(a,b)    scanf("%d %d", &a, &b)
 #define  sfff(a,b,c) scanf("%d %d %d", &a, &b, &c)
 #define  sffff(a,b,c,d) scanf("%d %d %d %d", &a, &b, &c, &d)
 #define  pf          printf
 #define  FRE(i,a,b)  for(i = a; i <= b; i++)
 #define  FREE(i,a,b) for(i = a; i >= b; i--)
 #define  FRL(i,a,b)  for(i = a; i < b; i++)
 #define  FRLL(i,a,b) for(i = a; i > b; i--)
 #define  FIN         freopen("DATA.txt","r",stdin)
 #define  gcd(a,b)    __gcd(a,b)
 #define  lowbit(x)   x&-x
 #pragma  comment (linker,"/STACK:102400000,102400000")
 using namespace std;
 typedef long long  LL;
 typedef unsigned long long ULL;
 const int INF = 0x7fffffff;
 const int mod = 1e9 + ;
 const int maxn = ;
 int t, cas = , R, C, n, pointx[maxn], pointy[maxn], x[maxn], y[maxn], vis[maxn][maxn];
 map<LL, LL>mpx, mpy;
 vector<int>cntx, cnty;
 int dx[] = {, , , -};
 int dy[] = {, -, , };
 LL sum = ;
 void dfs(int x, int y) {
     vis[x][y] = ;
     sum += 1LL * cntx[x] * cnty[y];
     for (int i =  ; i <  ; i++) {
         int nx = x + dx[i];
         int ny = y + dy[i];
         if (nx >=  && nx < cntx.size() && ny >=  && ny < cnty.size() && !vis[nx][ny]) dfs(nx, ny);
     }
 }
 void init(){
     mpx.clear(),mpy.clear();
     cntx.clear(),cnty.clear();
     mem(vis,);
 }
 LL ans[maxn];
 int main() {
     sf(t);
     while(t--) {
         sff(R, C);
         sf(n);
         init();
         int cnt1 = , cnt2 = ;
         x[cnt1++] = , x[cnt1++] = R;
         y[cnt2++] = , y[cnt2++] = C;
         for (int i =  ; i <= n ; i++) {
             sff(pointx[i], pointy[i]);
             x[cnt1++] = pointx[i];
             y[cnt2++] = pointy[i];
         }
         sort(x, x + cnt1);
         sort(y, y + cnt2);
         cnt1 = unique(x, x + cnt1) - x;
         cnt2 = unique(y, y + cnt2) - y;
         for (int i =  ; i < cnt1 ; i++) {
             int len = x[i] - x[i - ];
             if (len > ) cntx.push_back(len - );
             cntx.push_back();
             mpx[x[i]] = cntx.size() - ;
         }
         for (int i =  ; i < cnt2 ; i++) {
             int len = y[i] - y[i - ];
             if (len > ) cnty.push_back(len - );
             cnty.push_back();
             mpy[y[i]] = cnty.size() - ;
         }
         for (int i =  ; i <= n ; i++)
             vis[mpx[pointx[i]]][mpy[pointy[i]]] = ;
         int k = ;
         for (int i =  ; i < cntx.size() ; i++) {
             for (int j =  ; j < cnty.size() ; j++) {
                 if (!vis[i][j]) {
                     sum = ;
                     dfs(i, j);
                     ans[k++] = sum;
                 }
             }
         }
         sort(ans,ans+k);
         printf("Case #%d:\n", cas++);
         printf("%d\n",k);
         for (int i =  ; i < k ; i++)
             printf("%lld%c", ans[i], i == k -  ? '\n' : ' ');
     }
     return ;
 }