[bzoj4025][动态树]二分图

4025: 二分图

Time Limit: 20 Sec Memory Limit: 512 MB
Submit: 2174 Solved: 792
[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

[Submit][Status][Discuss]


sol:

显然动态树。L排序，维护R的最大生成树，做的过程中如果出现奇环的话就把树边和新边中较小的那条边丢到桶里。一个时间中如果桶里没东西的话就说明是二分图。
有个坑点就是自环特判一下。
网上有些选手的代码好像出现多个相同的自环的话他只会记一个所以会错。

#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<map>
using namespace std;

inline int read()
{
    char c;
    bool pd=0;
    while((c=getchar())>'9'||c<'0')
    if(c=='-') pd=1;
    int res=c-'0';
    while((c=getchar())>='0'&&c<='9')
    res=(res<<3)+(res<<1)+c-'0';
    return pd?-res:res;
}
const int N=310000;
int rev[N],lc[N],rc[N],fa[N],size[N];
int acnt,cnt[N],Min[N],val[N],key;
int to[N][2];
inline int new_node(int y,int c1,int c2)
{
    int x=++key;
    Min[x]=x;
    val[x]=y;
    to[x][0]=c1;
    to[x][1]=c2;
    return x;
}
int n;
inline void updata(int x)
{
    size[x]=size[lc[x]]+size[rc[x]]+(x<=n);
    if(val[Min[lc[x]]]>val[Min[rc[x]]]) Min[x]=Min[rc[x]];
    else Min[x]=Min[lc[x]];
    if(val[x]<val[Min[x]]) Min[x]=x;
}
inline void tag_rev(int x)
{
    rev[x]=!rev[x];
    swap(lc[x],rc[x]);
}
inline void tag_down(int x)
{
    if(rev[x])
    {
        rev[x]=0;
        tag_rev(lc[x]);
        tag_rev(rc[x]);
    }
}
inline void rotate(int x)
{
    int y=fa[x],z=fa[y];
    int b=lc[y]==x?rc[x]:lc[x];
    if(b) fa[b]=y;
    fa[y]=x;fa[x]=z;
    if(z)
    {
        if(lc[z]==y) lc[z]=x;
        if(rc[z]==y) rc[z]=x;
    }
    if(lc[y]==x) lc[y]=b,rc[x]=y;
    else rc[y]=b,lc[x]=y;
    updata(y);
}
int sta[N];
inline bool is_root(int x)
{
    return lc[fa[x]]!=x&&rc[fa[x]]!=x;
}
inline void splay(int x)
{
    sta[sta[0]=1]=x;
    for(int y=x;!is_root(y);y=fa[y]) sta[++sta[0]]=fa[y];
    while(sta[0]) tag_down(sta[sta[0]--]);
    while(!is_root(x))
    {
        if(!is_root(fa[x]))
        {
            if((lc[fa[fa[x]]]==fa[x])==(lc[fa[x]]==x)) rotate(fa[x]);
            else rotate(x);
        }
        rotate(x);
    }
    updata(x);
}
inline void access(int q)
{
    for(int p=0;q;p=q,q=fa[q])
    {
        splay(q);
        rc[q]=p;
        updata(q);
    }
}
inline void make_root(int x)
{
    access(x);
    splay(x);
    tag_rev(x);
}
inline void link(int x,int y)
{
    make_root(x);
    fa[x]=y;
}
inline int find_root(int x)
{
    access(x);
    splay(x);
    tag_down(x);
    while(lc[x])
    {
        x=lc[x];
        tag_down(x);
    }
    return x;
}
inline void cut(int x,int y)
{
    make_root(x);
    access(y);
    splay(x);
    rc[x]=fa[y]=0;
    updata(x);
}
int tim;
inline void add(int x,int y,int z)
{
    if(x==y)
    {
        acnt++;
        cnt[z]++;
        return;
    }
    if(find_root(x)==find_root(y))
    {
        make_root(x);
        access(y);
        splay(x);
        if(val[Min[x]]>=z)
        {
            if(size[x]&1)
            {
                acnt++;
                cnt[z]++;
            }
            return;
        }
        if((size[x]&1)&&val[Min[x]]>tim)
        {
            acnt++;
            cnt[val[Min[x]]]++;
        }
        int c=Min[x];
        cut(c,to[c][0]);
        cut(c,to[c][1]);
    }
    int c=new_node(z,x,y);
    link(c,x);
    link(c,y);
}
int m,q;
struct cc
{
    int x,y,l,r;
    friend inline bool operator <(const cc &a,const cc &b)
    {
        return a.l<b.l||a.l==b.l&&a.r<b.r;
    }
}b[N];
const int inf=1e8;
int main()
{
//  freopen("4025.in","r",stdin);
    n=key=read();
    m=read();
    q=read();
    val[0]=inf;
    for(int i=1;i<=n;++i) val[i]=inf;
    for(int i=1;i<=m;++i)
    {
        b[i].x=read();
        b[i].y=read();
        b[i].l=read()+1;
        b[i].r=read()+1;
    }
    sort(b+1,b+1+m);
    int fir=1;
    for(tim=1;tim<=q;++tim)
    {
        while(fir<=m&&b[fir].l<=tim)
        {
            add(b[fir].x,b[fir].y,b[fir].r);
            ++fir;
        }
        acnt-=cnt[tim];
        puts(acnt?"No":"Yes");
    }
}