[BZOJ4025]二分图（lct）

题目描述

传送门

题解

写lct就应该有那种誓死不看板子的气魄。

感觉这道题是挺好的一道题
首先考虑二分图的性质：不能有奇环！所以实际上这道题就是判断当前是否有奇环
那么先考虑一张静态的图如何判断是否存在奇环。可以发现，先对这个图搞出来一棵生成树，然后将非树边依次加入，每一次只判断这条边和树边是否成奇环，如果都不是奇环，那么一定没有奇环（只有一条公共边的两个偶环组合起来还是偶环）
那么考虑动态地维护一颗生成树，然后判断即可
因为支持删除，所以维护一棵以删除时间为权的最大生成树，记录每一条边是否形成了奇环（非树边）。删边的时候如果是树边就直接删掉，如果是非树边就更新一下奇环数量，然后每一次判断奇环数即可
这样的话一定不存在删掉一条树边要用已有的一条边来补充的情况，因为是删除时间的最大生成树

代码

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

int n,m,T,sz,cnt,odd;
struct data
{
    int x,y,t,opt,id;
    bool operator < (const data &a) const
    {
        return t<a.t||t==a.t&&opt>a.opt;
    }
}e[400005];
int flag[200005],tree[200005],l[300005],r[300005],pt[200005],re[300005],val[300005];
int f[300005],ch[300005][2],size[300005],rev[300005],minn[300005],stack[300005];

//--------------------------lct----------------------------
bool isroot(int x)
{
    return ch[f[x]][0]!=x&&ch[f[x]][1]!=x;
}
int get(int x)
{
    return ch[f[x]][1]==x;
}
void update(int x)
{
    size[x]=1;int loc=x;
    if (ch[x][0])
    {
        size[x]+=size[ch[x][0]];
        if (val[minn[ch[x][0]]]<val[loc])
            loc=minn[ch[x][0]];
    }
    if (ch[x][1])
    {
        size[x]+=size[ch[x][1]];
        if (val[minn[ch[x][1]]]<val[loc])
            loc=minn[ch[x][1]];
    }
    minn[x]=loc;
}
void pushdown(int x)
{
    if (x&&rev[x])
    {
        if (ch[x][0]) rev[ch[x][0]]^=1;
        if (ch[x][1]) rev[ch[x][1]]^=1;
        swap(ch[x][0],ch[x][1]);
        rev[x]=0;
    }
}
void rotate(int x)
{
    int old=f[x],oldf=f[old],wh=get(x);
    if (!isroot(old)) ch[oldf][ch[oldf][1]==old]=x;
    f[x]=oldf;
    ch[old][wh]=ch[x][wh^1];
    if (ch[old][wh]) f[ch[old][wh]]=old;
    ch[x][wh^1]=old;
    f[old]=x;
    update(old);
    update(x);
}
void splay(int x)
{
    int top=0;stack[++top]=x;
    for (int i=x;!isroot(i);i=f[i]) stack[++top]=f[i];
    for (int i=top;i;--i) pushdown(stack[i]);

    for (int fa;!isroot(x);rotate(x))
        if (!isroot(fa=f[x]))
            rotate((get(x)==get(fa))?fa:x);
}
void access(int x)
{
    int t=0;
    for (;x;t=x,x=f[x])
    {
        splay(x);
        ch[x][1]=t;
        update(x);
    }
}
void reverse(int x)
{
    access(x);
    splay(x);
    rev[x]^=1;
}
void link(int x,int y)
{
    reverse(x);
    f[x]=y;
}
void cut(int x,int y)
{
    reverse(x);
    access(y);
    splay(y);
    ch[y][0]=f[x]=0;
}
int find(int x)
{
    access(x);
    splay(x);
    while (ch[x][0]) x=ch[x][0];
    return x;
}
//-----------------------operation-------------------------
void add(int i)
{
    int x=e[i].x,y=e[i].y,t=e[i].opt,id=e[i].id;
    if (x==y)
    {
        flag[id]=1;
        ++odd;
        return;
    }
    if (find(x)==find(y))
    {
        reverse(x);
        access(y);
        splay(y);
        int loc=minn[y];
        int num=size[y]>>1;
        if (val[loc]>=t)
        {
            if (!(num&1))
            {
                ++odd;
                flag[id]=1;
            }
            return;
        }
        else
        {
            if (!(num&1))
            {
                ++odd;
                flag[re[loc]]=1;
            }
            cut(loc,l[loc]);
            cut(loc,r[loc]);
            tree[re[loc]]=0;
        }
    }
    ++sz;
    val[sz]=t;pt[id]=sz;re[sz]=id;
    l[sz]=x,r[sz]=y;
    link(x,sz);
    link(y,sz);
    tree[id]=1;
}
//-------------------------------main--------------------------------
int main()
{
    scanf("%d%d%d",&n,&m,&T);
    for (int i=1;i<=m;++i)
    {
        int x,y,st,ed;
        scanf("%d%d%d%d",&x,&y,&st,&ed);
        if (x>y) swap(x,y);
        e[++cnt].x=x,e[cnt].y=y,e[cnt].t=st,e[cnt].opt=ed,e[cnt].id=i;
        e[++cnt].x=x,e[cnt].y=y,e[cnt].t=ed,e[cnt].opt=-1,e[cnt].id=i;
    }
    sort(e+1,e+cnt+1);
    memset(val,127,sizeof(val));
    int now=1;sz=n,odd=0;
    for (int i=0;i<T;++i)
    {
        for (;now<=cnt&&e[now].t<=i;++now)
            if (e[now].opt==-1)
            {
                if (tree[e[now].id])
                {
                    odd-=flag[e[now].id];
                    flag[e[now].id]=0;
                    tree[e[now].id]=0;
                    cut(pt[e[now].id],l[pt[e[now].id]]);
                    cut(pt[e[now].id],r[pt[e[now].id]]);
                }
                else
                {
                    odd-=flag[e[now].id];
                    flag[e[now].id]=0;
                }
            }
            else add(now);
        if (odd) puts("No");
        else puts("Yes");
    }
}