洛谷P3300 城市规划

题意：给你一个6 * n的网格题，单点修改，询问区间联通块数。n <= 10w

解：看起来就很显然的一道题......线段树每个点用一个ufs维护连通性。完了。

我为了方便思考把图转成横着的了。

写起来真是毒瘤......

重点在于：1.建立叶节点。2.合并两个子节点。3.把新的并查集的中间两列压掉。

第一步，这个就直接枚举，merge就完事了。

第二步，把两个2列的子并查集copy到当前节点的4列的并查集上。注意右边那个并查集，fa全部要加2m，因为下标加了2m。

然后枚举中间两列merge。这样也做完了。

第三步，我们只要保留两边的两列即可。注意到有可能有两边元素的代表元在中间，我们使用左偏树技巧，切换代表元到它自己，注意vis也要变。

然后把两边的vis和facopy一份出来，用以查询代表元。

然后把前两列init，然后枚举每个元素，跟它的代表元merge。注意这一步会对连通块总数tot造成改变，最后复原即可。

最后把前两列的vis和lk从copy的那里拿来用即可。

注意，vis(当前联通块是否有建筑物)要继承代表元的，lk(能否与两边连通)直接从对应下标继承，这两个不一样！

具体实现看代码吧......

#include <bits/stdc++.h>

#define ck(x) ((x) == '+' || (x) == '|')

const int N = 100010;

template <typename T> inline void read(T &x) {
    x = 0;
    char c = getchar();
    while(c < '0' || c > '9') {
        c = getchar();
    }
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - 48;
        c = getchar();
    }
    return;
}

int n, m, gt[24], GT, exfa[24], exvis[24], exlk[24], newvis[24], newlk[24];

int exfind(int x) {
    return (x == exfa[x]) ? x : exfa[x] = exfind(exfa[x]);
}

inline int trans(int x) {
    return x < m ? x : x - (m << 1);
}

struct Node {
    int fa[24], tot;
    std::bitset<24> lk, vis;
    int find(int x) {
        return (x == fa[x]) ? x : (fa[x] = find(fa[x]));
    }
    inline void Merge(int x, int y) {
        x = find(x);
        y = find(y);
        if(x == y) return;
        fa[y] = x;
        tot -= (vis[x] && vis[y]);
        if(vis[y]) vis.set(x);
        return;
    }
    Node() {}
    Node(char *a) {
        tot = 0;
        for(register int i(0); i < m; ++i) {
            fa[i + m] = fa[i] = i;
            if(a[i] == 'O') {
                vis.set(i);
                vis.set(i + m);
                lk.set(i);
                lk.set(i + m);
                ++tot;
            }
            else if(a[i] == '.') {
                vis.reset(i);
                vis.reset(i + m);
                lk.reset(i);
                lk.reset(i + m);
            }
            else if(a[i] == '-' || a[i] == '+') {
                vis.reset(i);
                vis.reset(i + m);
                lk.set(i);
                lk.set(i + m);
            }
        }
        for(register int i(1); i < m; ++i) {
            if(ck(a[i - 1]) && ck(a[i])) {
                Merge(i - 1, i);
            }
            else if((ck(a[i - 1]) && a[i] == 'O') || (ck(a[i]) && a[i - 1] == 'O')) {
                Merge(i - 1, i);
            }
            else if(a[i] == 'O' && a[i - 1] == 'O') {
                Merge(i - 1, i);
            }
        }
    }
    inline void update() {
        for(register int i(0); i < m; ++i) {
            int t(find(i));
            fa[i] = fa[t] = i;
            vis[i] = vis[t];

            t = find(i + m * 3);
            fa[i + m * 3] = fa[t] = i + m * 3;
            vis[i + m * 3] = vis[t];
        }

        memcpy(exfa, fa, sizeof(fa));
        for(register int i(0); i < m; ++i) {
            exvis[i] = vis[i];
            exvis[i + m * 3] = vis[i + m * 3];
            exlk[i] = lk[i];
            exlk[i + m * 3] = lk[i + m * 3];
        }

        int temp = tot;
        for(register int i(0); i < m; ++i) {
            fa[i] = i;
            fa[i + m] = i + m;
        }
        for(register int i(0); i < m; ++i) {
            Merge(i, trans(exfind(i)));
            Merge(i + m, trans(exfind(i + m * 3)));
        }
        for(register int i(0); i < m; ++i) {
            vis[i] = exvis[exfind(i)];
            vis[i + m] = exvis[exfind(i + m * 3)];
            lk[i] = exlk[i];
            lk[i + m] = exlk[i + m * 3];
        }
        tot = temp;
        return;
    }
    inline Node merge(const Node &w) const {
        Node ans;
        /// copy
        for(register int i(0); i < m; ++i) {
            ans.fa[i] = fa[i];
            ans.lk[i] = lk[i];
            ans.vis[i] = vis[i];

            ans.fa[i + m] = fa[i + m];
            ans.lk[i + m] = lk[i + m];
            ans.vis[i + m] = vis[i + m];

            ans.fa[i + m * 2] = w.fa[i] + m * 2;
            ans.lk[i + m * 2] = w.lk[i];
            ans.vis[i + m * 2] = w.vis[i];

            ans.fa[i + m * 3] = w.fa[i + m] + m * 2;
            ans.lk[i + m * 3] = w.lk[i + m];
            ans.vis[i + m * 3] = w.vis[i + m];
        }
        ans.tot = tot + w.tot;
        /// merge
        for(register int i(0); i < m; ++i) {
            if(ans.lk[i + m] && ans.lk[i + m * 2]) { /// -> <-
                ans.Merge(i + m, i + m * 2);
            }
        }
        ans.update();
        return ans;
    }
}node[N << 2];

char str[N][6];

void build(int l, int r, int o) {
    if(l == r) {
        node[o] = Node(str[r]);
        return;
    }
    int mid = (l + r) >> 1;
    build(l, mid, o << 1);
    build(mid + 1, r, o << 1 | 1);
    node[o] = node[o << 1].merge(node[o << 1 | 1]);
    return;
}

void change(int p, int l, int r, int o) {
    if(l == r) {
        node[o] = Node(str[r]);
        return;
    }
    int mid = (l + r) >> 1;
    if(p <= mid) {
        change(p, l, mid, o << 1);
    }
    else {
        change(p, mid + 1, r, o << 1 | 1);
    }
    node[o] = node[o << 1].merge(node[o << 1 | 1]);
    return;
}

Node ask(int L, int R, int l, int r, int o) {
    if(L <= l && r <= R) {
        return node[o];
    }
    int mid = (l + r) >> 1;
    if(R <= mid) {
        return ask(L, R, l, mid, o << 1);
    }
    if(mid < L) {
        return ask(L, R, mid + 1, r, o << 1 | 1);
    }
    Node temp(ask(L, R, l, mid, o << 1));
    temp = temp.merge(ask(L, R, mid + 1, r, o << 1 | 1));
    return temp;
}

int main() {

    read(n); read(m);
    for(int i = 1; i <= n; i++) {
        scanf("%s", str[i]);
        for(int j = 0; j < m; j++) {
            if(str[i][j] == '-') {
                str[i][j] = '|';
            }
            else if(str[i][j] == '|') {
                str[i][j] = '-';
            }
        }
    }

    build(1, n, 1);

    int q, x, y;
    char ss[2];
    read(q);
    for(int i = 1; i <= q; i++) {
        scanf("%s", ss); read(x); read(y);
        if(ss[0] == 'C') { /// change
            scanf("%s", ss);
            if(ss[0] == '-') {
                ss[0] = '|';
            }
            else if(ss[0] == '|') {
                ss[0] = '-';
            }
            str[x][y - 1] = ss[0];
            change(x, 1, n, 1);
        }
        else { /// Query
            Node temp = ask(x, y, 1, n, 1);
            printf("%d
", temp.tot);
        }
    }

    return 0;
}

这代码常数奇大...