BZOJ4025: 二分图（LCT）

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

解题思路：

LCT维护图的连通性很好的一道题。

发现如果是树那么一定可以，如果奇数环一定不是。

离线一下，然后维护一颗树中最早被删除的点。

维护最后一条边（可以用数组存）

最后判一下就好了。

代码：

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #define lll tr[spc].ch[0]
 #define rrr tr[spc].ch[1]
 #define ls ch[0]
 #define rs ch[1]
 using std::swap;
 using std::sort;
 const int E=;
 struct trnt{
     int ch[];
     int fa;
     int lzt;
     int val;
     int mnp;
     int mn;
     int sum;
     int tip;
     bool anc;
 }tr[];
 struct ent{
     int f,t,dl;
 }e[];
 struct Event{
     bool cmd;
     int f,t,tpc;
     int no;
 }ev[];
 int n,m,T;
 int num;
 int cnt;
 bool onr[];
 bool odd[];
 bool whc(int spc)
 {
     return tr[tr[spc].fa].rs==spc;
 }
 void pushup(int spc)
 {
     tr[spc].sum=tr[spc].val;
     tr[spc].mn=tr[spc].tip;
     tr[spc].mnp=spc;
     if(lll)
     {
         tr[spc].sum+=tr[lll].sum;
         if(tr[spc].mn>tr[lll].mn)
         {
             tr[spc].mn=tr[lll].mn;
             tr[spc].mnp=tr[lll].mnp;
         }
     }
     if(rrr)
     {
         tr[spc].sum+=tr[rrr].sum;
         if(tr[spc].mn>tr[rrr].mn)
         {
             tr[spc].mn=tr[rrr].mn;
             tr[spc].mnp=tr[rrr].mnp;
         }
     }
     return ;
 }
 void trr(int spc)
 {
     if(!spc)
         return ;
     tr[spc].lzt^=;
     swap(lll,rrr);
     return ;
 }
 void pushdown(int spc)
 {
     if(tr[spc].lzt)
     {
         tr[spc].lzt=;
         trr(lll);
         trr(rrr);
     }
     return ;
 }
 void recal(int spc)
 {
     if(!tr[spc].anc)
         recal(tr[spc].fa);
     pushdown(spc);
     return ;
 }
 void rotate(int spc)
 {
     int f=tr[spc].fa;
     bool k=whc(spc);
     tr[f].ch[k]=tr[spc].ch[!k];
     tr[spc].ch[!k]=f;
     if(tr[f].anc)
     {
         tr[spc].anc=;
         tr[f].anc=;
     }else
         tr[tr[f].fa].ch[whc(f)]=spc;
     tr[spc].fa=tr[f].fa;
     tr[f].fa=spc;
     tr[tr[f].ch[k]].fa=f;
     pushup(f);
     pushup(spc);
     return ;
 }
 void splay(int spc)
 {
     recal(spc);
     while(!tr[spc].anc)
     {
         int f=tr[spc].fa;
         if(tr[f].anc)
         {
             rotate(spc);
             return ;
         }
         if(whc(spc)^whc(f))
             rotate(spc);
         else
             rotate(f);
         rotate(spc);
     }
     return ;
 }
 void access(int spc)
 {
     int lst=;
     while(spc)
     {
         splay(spc);
         tr[rrr].anc=;
         tr[lst].anc=;
         rrr=lst;
         pushup(spc);
         lst=spc;
         spc=tr[spc].fa;
     }
     return ;
 }
 void Mtr(int spc)
 {
     access(spc);
     splay(spc);
     trr(spc);
     return ;
 }
 void split(int x,int y)
 {
     Mtr(x);
     access(y);
     splay(y);
     return ;
 }
 int finf(int spc)
 {
     access(spc);
     splay(spc);
     while(lll)
         spc=lll;
     return spc;
 }
 void link(int x,int y)
 {
     Mtr(x);
     tr[x].fa=y;
     return ;
 }
 void cut(int x,int y)
 {
     split(x,y);
     tr[x].fa=tr[y].ls=;
     tr[x].anc=;
     pushup(y);
     return ;
 }
 void Insert(int frm,int twd,int spc,int Time)
 {
     if(frm==twd)
     {
         num++;
         odd[spc]=true;
         return ;
     }
     Mtr(frm);
     if(finf(twd)==frm)
     {
         int x=tr[twd].mnp-E;
         if(e[x].dl<Time)
         {
             onr[x]=false;
             onr[spc]=true;
             if(tr[twd].sum%==)
             {
                 odd[x]=true;
                 num++;
             }
             cut(e[x].f,x+E);
             cut(e[x].t,x+E);
             link(frm,spc+E);
             link(twd,spc+E);
         }else{
             if(tr[twd].sum%==)
             {
                 odd[spc]=true;
                 num++;
             }
         }
     }else{
         link(frm,spc+E);
         link(twd,spc+E);
         onr[spc]=true;
     }
     return ;
 }
 void Delete(int frm,int twd,int spc)
 {
     if(onr[spc])
     {
         cut(frm,spc+E);
         cut(twd,spc+E);
         onr[spc]=false;
         return ;
     }
     if(odd[spc])
     {
         odd[spc]=false;
         num--;
     }
     return ;
 }
 bool cmp(Event x,Event y)
 {
     return x.tpc<y.tpc;
 }
 int main()
 {
     scanf("%d%d%d",&n,&m,&T);
     for(int i=;i<=n;i++)
     {
         tr[i].anc=;
         tr[i].tip=0x3f3f3f3f;
     }
     for(int i=;i<=m;i++)
     {
         int a,b,c,d;
         scanf("%d%d%d%d",&a,&b,&c,&d);
         ev[++cnt]=(Event){,a,b,c,i};
         ev[++cnt]=(Event){,a,b,d,i};
         e[i]=(ent){a,b,d};
         int spc=i+E;
         tr[spc].anc=;
         tr[spc].mn=d;
         tr[spc].tip=d;
         tr[spc].mnp=i;
         tr[spc].val=;
     }
     sort(ev+,ev+cnt+,cmp);
     for(int i=,hpn=;i<=T;i++)
     {
         for(;(hpn<=cnt)&&(ev[hpn].tpc<i);hpn++)
         {
             Event x=ev[hpn];
             if(!x.cmd)
                 Insert(x.f,x.t,x.no,e[x.no].dl);
             else
                 Delete(x.f,x.t,x.no);
         }
         if(num)
             puts("No");
         else
             puts("Yes");
     }
     return ;
 }