Artwork Gym

题目：题目链接

思路：每个空白区域当作一个并查集，因为正着使用并查集分割的话dfs会爆栈，判断过于复杂也会导致超时，我们采用离线反向操作，先全部涂好，然后把黑格子逐步涂白，我们把每个空白区域当作一个并查集，然后采用合并并查集的方法来做，好困啊，明天还有课，具体思路有空再写吧，先睡觉了。

AC代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>

using namespace std;

#define y1 yy1
#define y2 _y2

const int maxn = 1000 + 5;
const int maxq = 10000 + 5;
    
int grid[maxn][maxn], x1[maxq], y1[maxq], x2[maxq], y2[maxq], num[maxn * maxn], n, m, q, sum, ans[maxq];

int cx[] = { -1, 0, 1, 0 };
int cy[] = { 0, -1, 0, 1 };

void init();
int cal(int, int);
bool judge(int, int);
void unite(int, int);
int _find(int);
void solve();

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);

    cin >> n >> m >> q;

    for (int i = 1; i <= q; ++i) {
        cin >> x1[i] >> y1[i] >> x2[i] >> y2[i];
        if (x1[i] == x2[i])
            for (int j = y1[i]; j <= y2[i]; ++j)
                ++grid[x1[i]][j];
        else
            for (int j = x1[i]; j <= x2[i]; ++j)
                ++grid[j][y1[i]];
    }

    init();

    solve();

    for (int i = 1; i <= q; ++i)
        cout << ans[i] << endl;

    return 0;
}

void init() {
    for (int i = 0; i <= n * m; ++i)
        num[i] = i;

    sum = n * m;

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            if (!grid[i][j]) {
                for (int k = 0; k < 4; ++k) {
                    if (judge(i + cx[k], j + cy[k]) && !grid[i + cx[k]][j + cy[k]]) {
                        unite(cal(i, j), cal(i + cx[k], j + cy[k]));
                    }
                }
            }
            else 
                --sum;
        }
    }
}

int cal(int x, int y) {
    return (x - 1) * m + y;
}

bool judge(int x, int y) {
    return x > 0 && x <= n && y > 0 && y <= m;
}

void unite(int x, int y) {
    int a = _find(x), b = _find(y);
    if (a == b)
        return;

    --sum;
    num[a] = b;
}

int _find(int x) {
    return x == num[x] ? x : num[x] = _find(num[x]);
}

void solve() {
    for (int i = q; i > 0; --i) {
        ans[i] = sum;
        if (x1[i] == x2[i]) {
            for (int j = y1[i]; j <= y2[i]; ++j) {
                --grid[x1[i]][j];
                if (!grid[x1[i]][j]) {
                    ++sum;
                    for (int k = 0; k < 4; ++k) {
                        if (judge(x1[i] + cx[k], j + cy[k]) && !grid[x1[i] + cx[k]][j + cy[k]])
                            unite(cal(x1[i], j), cal(x1[i] + cx[k], j + cy[k]));
                    }
                }
            }
        }
        else {
            for (int j = x1[i]; j <= x2[i]; ++j) {
                --grid[j][y1[i]];
                if (!grid[j][y1[i]]) {
                    ++sum;
                    for (int k = 0; k < 4; ++k)
                        if (judge(j + cx[k], y1[i] + cy[k]) && !grid[j + cx[k]][y1[i] + cy[k]])
                            unite(cal(j, y1[i]), cal(j + cx[k], y1[i] + cy[k]));
                }
            }
        }
    }
}