bzoj4025二分图 线段树分治+并查集

4025: 二分图

Time Limit: 20 Sec   Memory Limit: 512 MB
Submit: 1761   Solved: 654
[ Submit][ Status][ Discuss]

Description

神犇有一个n个节点的图。因为神犇是神犇，所以在T时间内一些边会出现后消失。神犇要求出每一时间段内这个图是否是二分图。这么简单的问题神犇当然会做了，于是他想考考你。

Input

输入数据的第一行是三个整数n,m,T。

第2行到第m+1行，每行4个整数u,v,start,end。第i+1行的四个整数表示第i条边连接u,v两个点，这条边在start时刻出现，在第end时刻消失。

Output

输出包含T行。在第i行中，如果第i时间段内这个图是二分图，那么输出“Yes”，否则输出“No”，不含引号。

Sample Input

3 3 3
1 2 0 2
2 3 0 3
1 3 1 2

Sample Output

Yes
No
Yes

HINT

样例说明：

0时刻，出现两条边1-2和2-3。

第1时间段内，这个图是二分图，输出Yes。

1时刻，出现一条边1-3。

第2时间段内，这个图不是二分图，输出No。

2时刻，1-2和1-3两条边消失。

第3时间段内，只有一条边2-3，这个图是二分图，输出Yes。

数据范围：

n<=100000，m<=200000，T<=100000，1<=u,v<=n，0<=start<=end<=T。

Source

嗯，一看题目，哇，穿着衣服的LCT！

然后就打了线段树分治。

关于线段树分治是什么看这里：戳这里

这题直接的对时间线段树分治。然后二分图和无奇环是充分必要的。

这里有一个神奇的带权并查集判奇环的方式。

这个时候我们希望维护两点间路径长度的奇偶性。

这里有一个神奇的方法，给每个点一个权值c，然后d为从x和y到根的异或值。然后合并的时候如果把x合并到y，另c[p[x]] = d[x]^d[y]^1(p[x]为x的并查集根)

每次修改c，安秩合并查询d就可以了。

关于并查集的操作和NOIP2010的监狱那道很像，这个做法的证明在这里：点我

代码：

#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
#include<cmath>
#include<vector>
using namespace std;
const int N = 2e5 + 1e3;
int read() {
    char ch = getchar(); int x = 0, f = 1;
    while(ch < '0' || ch > '9') {if(ch == '-') f = -1; ch = getchar();}
    while(ch >= '0' && ch <= '9') {x = (x << 1) + (x << 3) - '0' + ch; ch = getchar();}
    return x * f;
}
struct node {int u, v, s, t;};
vector<node>S;
int f[N], rank[N], st[N], str[N], d[N], top;
bool ans[N];
 
int find(int x) {for(;x != f[x]; x = f[x]) ; return x;}
int getd(int x) {int ret = 0; for(;x != f[x]; ret ^= d[x], x = f[x]) ; return ret;}
void merge(int u, int v, int w) {
    ++top;
    if(rank[u] < rank[v]) swap(u, v);
    if(rank[u] == rank[v]) ++rank[u], str[top] = u;
    else str[top] = 0;
    st[top] = v; f[v] = u; d[v] = w;
}
 
void restore(int now) {
    while(top != now) {
        if(str[top]) --rank[str[top]]; 
        f[st[top]] = st[top]; d[st[top]] = 0;
        --top;
    }
}
 
void Seg_solve(int L, int R, vector<node> e) {
    int mid = L + R >> 1, now = top; vector<node>l, r;
    for(int i = 0;i < e.size(); ++i) {
        if(L == e[i].s && R == e[i].t) {
            int fu = find(e[i].u), fv = find(e[i].v);
            int c = getd(e[i].u) ^ getd(e[i].v) ^ 1;
            if(fu != fv) merge(fu, fv, c);
            else if(c & 1) {
                for(int j = L;j <= R; ++j) ans[j] = false;
                restore(now);
                return;
            }
        }
        else {
            if(e[i].t <= mid) l.push_back(e[i]);
            else if(e[i].s > mid) r.push_back(e[i]);
            else {
                node lp, rp; lp = rp = e[i];
                lp.t = mid; rp.s = mid + 1;
                l.push_back(lp); r.push_back(rp);
            }
        }
    }
    if(L == R) ans[L] = true;
    else {
        Seg_solve(L, mid, l);
        Seg_solve(mid + 1, R, r);
    }
    restore(now);
}
 
int main() {
    int n = read(), m = read(), T = read();
    for(int i = 1;i <= n; ++i) f[i] = i;
    for(int i = 1;i <= m; ++i) {
        node t; t.u = read(); t.v = read(); t.s = read() + 1; t.t = read();
        if(t.s <= t.t) S.push_back(t);
    } 
    for(int i = 1;i <= T; ++i) ans[i] = true;
    Seg_solve(1, T, S);
    for(int i = 1;i <= T; ++i) puts(ans[i] ? "Yes" : "No");
    return 0;
}