HDU5354 Bipartite Graph (CDQ分治 + 并查集)

/**
题意：n个点m条边的无向图，问删除1~n其中一个点能否使图变为二分图

思路：CDQ分治 + 并查集， 要使图是二分图，可以用黑白染色图中的点，相邻的两点颜色不能相同，solve(l, r)
代表删除区间(l, r)中的所有点剩余的图是否是二分图,那么solve(l, mid)的时候，要将(mid + 1, r)中的所有点
加入集合，对于即将加入的点，先假设全部为黑色点，遍历它的所有边，对于(u, v)这条边
1. u, v属于不同集合，如果color(u) = color(v)， 那么u(或者v)所在的集合的所有点的颜色需要改变，即合并的时候
将其中一个集合的父节点的dis值加1，否则直接合并

2. u, v属于相同集合，如果color(u) = color(v)，那么直接产生了奇环，不行，对多有待处理的区间肯定所有都是NO,
否则继续

solve(l, mid)之后， 还需要将并查集的状态还原， 不怎么会就直接记录所有操作序列，之后逆序一步一步还原即可
**/

#include<bits/stdc++.h>
const int maxn = 1e5 + 10;
using namespace std;

struct P {
    int id, old_pre, old_dis;
    P() {}
    P(int i, int op, int od) : id(i), old_pre(op), old_dis(od) {}
};
int n, m, T, can[maxn], vis[maxn];
vector<int> G[maxn];
int pre[maxn], dis[maxn];


int findset(int x, vector<P> &vec) {
    if(x == pre[x]) return x;
    int nowp = pre[x];
    int p = findset(pre[x], vec);
    vec.push_back(P(x, nowp, dis[x]));
    dis[x] = (dis[nowp] + dis[x]) & 1; pre[x] = p;
    return p;
}

int deal_with(int l, int r, vector<P> &vec) {
    for(int i = l; i <= r; i++) {
        vis[i] = 1; vec.push_back(P(i, -1, 0));
        for(int j = 0; j < G[i].size(); j++) {
            int v = G[i][j];
            if(!(vis[v] || (v >= l && v <= r))) continue;
            int nx = findset(i, vec), ny = findset(v, vec);
            if(nx != ny) {
                int flag = (dis[i] == dis[v]);
                vec.push_back(P(nx, pre[nx], dis[nx]));
                pre[nx] = ny; dis[nx] = flag;
            } else {
                int d1 = dis[i], d2 = dis[v];
                if(d1 == d2) return 0;
            }
        }
    }
    return 1;
}

void return_old(vector<P> &vec) {
    for(int i = vec.size() - 1; i >= 0; i--) {
        P p = vec[i];
        int id = p.id, op = p.old_pre, od = p.old_dis;
        if(op != -1) { pre[id] = op; dis[id] = od; }
        else vis[id] = od;
    }
}

void solve(int l, int r) {
    if(l == r) { can[l] = 1; return ; }
    int mid = (l + r) >> 1;
    vector<P> vec;
    int flag = deal_with(mid + 1, r, vec);
    if(flag) solve(l, mid);
    return_old(vec); vec.clear();

    flag = deal_with(l, mid, vec);
    if(flag) solve(mid + 1, r);
    return_old(vec); vec.clear();
}

int main() {
    scanf("%d", &T);
    while(T--) {
        scanf("%d %d", &n, &m);
        for(int i = 1; i < maxn; i++) {
            G[i].clear(); can[i] = 0;
            pre[i] = i; dis[i] = 0; vis[i] = 0;
        }
        while(m--) {
            int u, v; scanf("%d %d", &u, &v);
            G[u].push_back(v); G[v].push_back(u);
        }
        solve(1, n);
        for(int i = 1; i <= n; i++) printf("%d", can[i]);
        printf("\n");
    }
    return 0;
}