BZOJ 3553: [Shoi2014]三叉神经树 LCT

犯傻了，想到了如果是 0->1 的话就找最深的非 1 编号，是 1 -> 0 的话就找最深的非 0 编号.

但是没有想到这个东西可以直接维护.

假设不考虑叶子节点，那么如果当前点的值是 1 的话要求儿子节点权和 > 1

假设当前从 0->1，那么该叶子造成的影响一定是一条向上的链.

如果向上走到某一时刻，该点的儿子权和不等于 1，那么这个点及以上就影响不到了.

如果权和为 2，那么在 0->1 之前就已经是 1 了，修改后也肯定还是 1.

如果权和为 0，那么在 0->1 之后顶多能把权和+1，所以做的时无用功.

所以，会造成影响的是以该叶子向上延伸的最长的全 1 链.

这些点全部会从 0 变成 1，然后做一个区间 +1 （全变成 2）

这里讲一下区间加的时候如何维护标记：

因为我们进行区间加的链肯定是全 1 / 2 的.

所以说，原来是全 1 的话原来的 1 的最深节点就消失，然后最深度节点是 2 的就会新产生.

然后你发现正好是 1->2, 2->0 或者 2->1, 1->0，所以直接交换一下 1 和 2 的编号即可.

#include <bits/stdc++.h>
using namespace std;
#define N 1600000
#define lson t[x].ch[0]
#define rson t[x].ch[1]
#define get(x)  (t[t[x].f].ch[1]==x)
#define isrt(x) (!(t[t[x].f].ch[0]==x||t[t[x].f].ch[1]==x))
#define setIO(s) freopen(s".in","r",stdin)
int n,m,edges;
int hd[N],to[N],nex[N],sta[N];
struct node
{
    int ch[2],id[3],f,add,val,sum;
}t[N];
inline void mark(int x,int add)
{
    if(!x) return;
    t[x].sum+=add,t[x].val=t[x].sum>1;
    swap(t[x].id[1],t[x].id[2]);
    t[x].add+=add;
}
inline void pushup(int x)
{
    t[x].id[1]=t[rson].id[1];
    t[x].id[2]=t[rson].id[2];
    if(!t[x].id[1])
    {
        if(t[x].sum!=1)  t[x].id[1]=x;
        else t[x].id[1]=t[lson].id[1];
    }
    if(!t[x].id[2])
    {
        if(t[x].sum!=2)  t[x].id[2]=x;
        else t[x].id[2]=t[lson].id[2];
    }
}
inline void pushdown(int x)
{
    if(t[x].add)
    {
        if(lson)   mark(lson,t[x].add);
        if(rson)   mark(rson,t[x].add);
        t[x].add=0;
    }
}
inline void rotate(int x)
{
    int old=t[x].f,fold=t[old].f,which=get(x);
    if(!isrt(old))  t[fold].ch[t[fold].ch[1]==old]=x;
    t[old].ch[which]=t[x].ch[which^1],t[t[old].ch[which]].f=old;
    t[x].ch[which^1]=old,t[old].f=x,t[x].f=fold;
    pushup(old),pushup(x);
}
void splay(int x)
{
    int u=x,v=0,fa;
    for(sta[++v]=u;!isrt(u);u=t[u].f)   sta[++v]=t[u].f;
    for(;v;--v)   pushdown(sta[v]);
    for(u=t[u].f;(fa=t[x].f)!=u;rotate(x))
    {
        if(t[fa].f!=u)
        {
            rotate(get(fa)==get(x)?fa:x);
        }
    }
}
inline void Access(int x)
{
    for(int y=0;x;y=x,x=t[x].f)
    {
        splay(x);
        rson=y;
        pushup(x);
    }
}
void add(int u,int v)
{
    nex[++edges]=hd[u],hd[u]=edges,to[edges]=v;
}
void dfs(int u)
{
    for(int i=hd[u];i;i=nex[i])    dfs(to[i]),t[u].sum+=t[to[i]].val;
    if(u<=n) t[u].val=t[u].sum>1;
}
int main()
{
    // setIO("input");
    int i,j,Q;
    scanf("%d",&n);
    for(i=1;i<=n;++i)
    {
        for(j=1;j<=3;++j)
        {
            int x;
            scanf("%d",&x),add(i,x),t[x].f=i;
        }
    }
    for(i=n+1;i<=3*n+1;++i)    scanf("%d",&t[i].val);
    dfs(1);
    scanf("%d",&Q);
    int ans=t[1].val;
    while(Q--)
    {
        int x;
        scanf("%d",&x);
        int tag=(t[x].val?-1:1),y=t[x].f;
        Access(y),splay(y);
        int w=t[y].id[t[x].val?2:1];
        if(w)
        {
            splay(w);
            mark(t[w].ch[1],tag);
            pushup(t[w].ch[1]);
            t[w].sum+=tag;
            t[w].val=t[w].sum>1;
            pushup(w);
        }
        else
        {
            ans^=1;
            mark(y,tag);
            pushup(y);
        }
        t[x].val^=1;
        printf("%d\n",ans);
    }
    return 0;
}