BZOJ - 1453 Dface双面棋盘 （并查集+线段树）

1453: [Wc]Dface双面棋盘

Time Limit: 10 Sec  Memory Limit: 64 MB
Submit: 847  Solved: 453
[Submit][Status][Discuss]

Description

Input

Output

Sample Input

Sample Output

HINT

 

 

Source

鸣谢刘汝佳先生授权使用

[Submit][Status][Discuss]

 

 

解题思路：维护联通块数量，肯定会想到并查集。但是这题只用并查集的话会发现很难或者无法处理。考虑暴力，每次翻转后，都重新建一个并查集，这样复杂度是M*N*N的。考虑优化，如果我们只修改一个点，那么可能会对他附近的点产生影响，而对离他较远的点可能没有影响。所以每次更新，我们不必遍历整个图重新建并查集。考虑只有两行的情况

1111100000111

0001111100000

我们单独看第一行，此时答案是 2 1，我们把第一行用并查集维护好。

然后当加入第二行的时候，单独看第二行的答案是 1 2

那么我们整体考虑的话，就要合并这两行！怎么合并呢？直接暴力！

遍历每一列，看看上下两点是否颜色相同且属于一个并查集即可。

 

那么我们发现，现在我们可以维护区间信息了！所以我们用线段树维护行信息即可。合并的时候即pushup的时候，暴力合并！

所以线段树上每个node我们都要维护他们的并查集信息！详细见代码。

 

#include <iostream>
#include <string.h>
#include <math.h>
#include <vector>
#include <algorithm>
#include <stdio.h>
using namespace std;
const int MAXN = 210;
typedef long long ll;

struct Node
{
    int L[MAXN], R[MAXN];//当前节点，最左边和最右边的点分别是属于哪个集合的
    int ans[2];//当前节点的答案
} tree[MAXN << 2];

int N, Q;

int fa[MAXN * MAXN];
int find(int x)
{
    return x == fa[x] ? x : fa[x] = find(fa[x]);
}

int G[MAXN][MAXN];

//根据行列计算编号
int id(int x, int y)
{
    return (x - 1) * N + y;
}

//合并两个节点的操作，其实就是push_up，这里直接暴力计算！，一共会merrge计算log(N)次，所以查询复杂度为Nlog(N)
Node merge(Node a, Node b, int m)
{
    Node c;
    for (int i = 1; i <= N; i++)//初始化
    {
        c.L[i] = a.L[i];
        c.R[i] = b.R[i];
        fa[a.L[i]] = a.L[i];//这里也要初始化，否则合并时会有问题。我们只关心tree[1]，所以线段树的子节点怎么改都没问题，不影响最后答案
        fa[a.R[i]] = a.R[i];
        fa[b.L[i]] = b.L[i];
        fa[b.R[i]] = b.R[i];
    }

    c.ans[0] = a.ans[0] + b.ans[0];
    c.ans[1] = a.ans[1] + b.ans[1];

    for (int i = 1; i <= N; i++)//暴力更新！妙啊
    {
        if (G[i][m] == G[i][m + 1])//不相等的话不用更新并查集了
        {
            int fx = find(a.R[i]);
            int fy = find(b.L[i]);
            if (fx != fy)
            {
                fa[fx] = fy;
                c.ans[G[i][m]]--;
            }
        }
    }
    for (int i = 1; i <= N; i++)
    {
        c.L[i] = find(c.L[i]);//保证L,R，必须是根，否则上面的初始化会有问题。
        c.R[i] = find(c.R[i]);
    }
    return c;
}

void build(int l, int r, int rt)
{
    if (l == r)
    {
        for (int i = 1; i <= N; i++)
        {
            tree[rt].L[i] = tree[rt].R[i] = fa[id(i, l)] = id(i, l);
            tree[rt].ans[G[i][l]]++;
        }
        for (int i = 2; i <= N; i++)
        {
            if (G[i][l] == G[i - 1][l])
            {
                fa[id(i, l)] = tree[rt].L[i] = tree[rt].R[i] = fa[id(i - 1, l)];
                tree[rt].ans[G[i][l]]--;
            }
        }
        return;
    }
    int m = (l + r) / 2;
    build(l, m, rt << 1);
    build(m + 1, r, rt << 1 | 1);
    tree[rt] = merge(tree[rt << 1], tree[rt << 1 | 1], m);
}

void update(int C, int l, int r, int rt)
{
    if (l == r)
    {
        tree[rt].ans[0] = tree[rt].ans[1] = 0;
        for (int i = 1; i <= N; i++)
        {
            tree[rt].L[i] = tree[rt].R[i] = fa[id(i, l)] = id(i, l);
            tree[rt].ans[G[i][l]]++;
        }
        for (int i = 2; i <= N; i++)
            if (G[i][l] == G[i - 1][l])
            {
                fa[id(i, l)] = tree[rt].L[i] = tree[rt].R[i] = fa[id(i - 1, l)];
                tree[rt].ans[G[i][l]]--;
            }
        return;
    }
    int m = (l + r) / 2;
    if (C <= m)
        update(C, l, m, rt << 1);
    else
        update(C, m + 1, r, rt << 1 | 1);
    tree[rt] = merge(tree[rt << 1], tree[rt << 1 | 1], m);
}

int main()
{
    scanf("%d", &N);
    for (int i = 1; i <= N; i++)
    {
        for (int j = 1; j <= N; j++)
        {
            scanf("%d", &G[i][j]);
        }
    }
    build(1, N, 1);
    scanf("%d", &Q);
    while (Q--)
    {
        int x, y;
        scanf("%d%d", &x, &y);
        G[x][y] ^= 1;
        update(y, 1, N, 1);//更新第Y列节点
        printf("%d %d\n", tree[1].ans[1], tree[1].ans[0]);
    }

    return 0;
}