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
, rank
, st
, str
, d
, top;
bool ans
;

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] = 1;
}

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;
}