AOJ 0531 坐标离散化

涂色：（日文题目，自己翻译成了中文）为了宣传信息竞赛，要在长方形的三合板上喷油漆来制作招牌。三合板上不需要涂色的部分预先贴好了护板。被护板隔开的区域要涂上不同的颜色，比如上图就应该涂上5种颜色。

请编写一个程序计算涂色数量，输入数据中，保证看板不会被护板全部遮住，并且护板的边一定是水平或垂直的。

输入：

第一个数是宽w（1 ≤ w ≤ 1000000），第二个数是高h（1 ≤ h ≤ 1000000）。

第二行是护板的数量n（1 ≤ n ≤ 1000），接着n行是每个护板的左下角坐标 (x1 , y1 )和右上角坐标 (x2 , y2 )，用空格隔开： x1 , y1 , x2 , y2 (0 ≤ x1< x2 ≤ w, 0 ≤ y1 < y2 ≤ h 都是整数)

招牌的坐标系如下，左下角是 (0, 0) ，右上角是(w, h) ， 测试集中的30%都满足w ≤ 100, h ≤ 100, n ≤ 100。

输出：

一个整数，代表涂色数量。

使用坐标离散化求解。

坐标离散化的思想是：当坐标范围很大而坐标数量很少时，可以考虑把所有用到的横坐标排序，然后用每个坐标对应的下标来更新坐标位置。

举例来说：

这个例子中的用到的横坐标有1,2,4,5,6,7,9,10,11,12,13,14。

那么横坐标对(1,5)就可以转化为(0,3)。节省了一位空间，这个节省在空隙变大后会越来越明显。

通过坐标离散化，通常时间复杂度就可以降到令人满意的程度了。

这里使用了imos法，进一步优化时间复杂度。

接下来是代码，来自http://www.hankcs.com/program/algorithm/aoj-0531-paint-color.html

 #include<iostream>
 #include<vector>
 #include<algorithm>
 #include<queue>
 #include <cstring>
 #define MAX_N 1000 + 16

 using namespace std;

 int N, H, W;
 int X1[MAX_N], X2[MAX_N], Y1[MAX_N], Y2[MAX_N];
 int fld[ * MAX_N][ * MAX_N], // 填充遍历用，代表坐标(i, j)处是否空白（压缩后）
 dx[] = { , -, ,  }, dy[] = { , , , - };

 // 压缩坐标，将坐标的值变成“这是第几种值”，返回一共有几种坐标
 int compress(int *x1, int *x2, int w)
 {
     vector<int>xs;

     for (int i = ; i < N; ++i)
     {
         int tx1 = x1[i], tx2 = x2[i];
         if ( <= tx1 && tx1 < w) xs.push_back(tx1);
         if ( <= tx2 && tx2 < w) xs.push_back(tx2);
     }
     xs.push_back();
     xs.push_back(w);
     sort(xs.begin(), xs.end());
     xs.erase(unique(xs.begin(), xs.end()), xs.end());
     for (int i = ; i < N; ++i)
     {
         x1[i] = find(xs.begin(), xs.end(), x1[i]) - xs.begin();
         x2[i] = find(xs.begin(), xs.end(), x2[i]) - xs.begin();
     }
     return xs.size() - ;
 }

 int bfs()
 {
     int ans = ;
     for (int i = ; i < H; ++i)
     {
         for (int j = ; j < W; ++j)
         {
             if (fld[i][j]) continue;
             ++ans;
             queue<pair<int, int> >que;
             que.push(make_pair(j, i));
             while (!que.empty())
             {
                 int nx = que.front().first, ny = que.front().second;
                 que.pop();

                 for (int i = ; i < ; ++i)
                 {
                     int tx = nx + dx[i], ty = ny + dy[i];
                     if (tx <  || W < tx || ty <  || H< ty || fld[ty][tx] > ) continue;
                     que.push(make_pair(tx, ty));
                     fld[ty][tx] = ;
                 }
             }
         }
     }
     return ans;
 }

 ///////////////////////////SubMain//////////////////////////////////
 int main(int argc, char *argv[])
 {
     while (cin >> W >> H, W | H)
     {
         cin >> N;
         for (int i = ; i < N; ++i)
         {
             cin >> X1[i] >> Y1[i] >> X2[i] >> Y2[i];
         }

         memset(fld, , sizeof(fld));

         W = compress(X1, X2, W);
         H = compress(Y1, Y2, H);

         // imos-法
         for (int i = ; i < N; i++)
         {
             fld[Y1[i]][X1[i]]++;
             fld[Y1[i]][X2[i]]--;
             fld[Y2[i]][X1[i]]--;
             fld[Y2[i]][X2[i]]++;
         }
         // 横向累积
         for (int i = ; i < H; i++)
         {
             for (int j = ; j < W; j++)
             {
                 fld[i][j] += fld[i][j - ];
             }
         }
         // 纵向累积
         for (int i = ; i < H; i++)
         {
             for (int j = ; j < W; j++)
             {
                 fld[i][j] += fld[i - ][j];
             }
         }// 累积完后，fld中非0部分表示有挡板
         cout << bfs() << endl;
     }
     return ;
 }
 ///////////////////////////End Sub//////////////////////////////////