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[2 * MAX_N][2 * MAX_N], // 填充遍历用，代表坐标(i, j)处是否空白（压缩后）
dx[4] = { 1, -1, 0, 0 }, dy[4] = { 0, 0, 1, -1 };
 
// 压缩坐标，将坐标的值变成“这是第几种值”，返回一共有几种坐标
int compress(int *x1, int *x2, int w)
{
    vector<int>xs;
 
    for (int i = 0; i < N; ++i)
    {
        int tx1 = x1[i], tx2 = x2[i];
        if (1 <= tx1 && tx1 < w) xs.push_back(tx1);
        if (1 <= tx2 && tx2 < w) xs.push_back(tx2);
    }
    xs.push_back(0);
    xs.push_back(w);
    sort(xs.begin(), xs.end());
    xs.erase(unique(xs.begin(), xs.end()), xs.end());
    for (int i = 0; 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() - 1;
}
 
int bfs()
{
    int ans = 0;
    for (int i = 0; i < H; ++i)
    {
        for (int j = 0; 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 = 0; i < 4; ++i)
                {
                    int tx = nx + dx[i], ty = ny + dy[i];
                    if (tx < 0 || W < tx || ty < 0 || H< ty || fld[ty][tx] > 0) continue;
                    que.push(make_pair(tx, ty));
                    fld[ty][tx] = 1;
                }
            }
        }
    }
    return ans;
}
 
///////////////////////////SubMain//////////////////////////////////
int main(int argc, char *argv[])
{
    while (cin >> W >> H, W | H)
    {
        cin >> N;
        for (int i = 0; i < N; ++i)
        {
            cin >> X1[i] >> Y1[i] >> X2[i] >> Y2[i];
        }
 
        memset(fld, 0, sizeof(fld));
 
        W = compress(X1, X2, W);
        H = compress(Y1, Y2, H);
 
        // imos-法
        for (int i = 0; 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 = 0; i < H; i++)
        {
            for (int j = 1; j < W; j++)
            {
                fld[i][j] += fld[i][j - 1];
            }
        }
        // 纵向累积
        for (int i = 1; i < H; i++)
        {
            for (int j = 0; j < W; j++)
            {
                fld[i][j] += fld[i - 1][j];
            }
        }// 累积完后，fld中非0部分表示有挡板
        cout << bfs() << endl;
    }
    return 0;
}
///////////////////////////End Sub//////////////////////////////////