[集训]Evocation

题意

一颗有根树，每个点有黑白两种颜色和阀值a_i，若它的子树中（不包括自己）的黑色数量大于a_i，则产生一点贡献。每次将一个点的颜色取反，求每次修改后的贡献。n，q<=1E5。

---

思考

树剖后直接分块就行了。复杂度约为O((n+q)sqrt(nlogn))，但似乎更小？

---

代码

#pragma GCC optimize 2
#include<bits/stdc++.h>
using namespace std;
const int maxn=1E5+5;
///////////////////////////////////////////////////////////////////////////////
int wait[maxn],wait_R[maxn],wait_C[maxn],wait_W[maxn];
template<class T>inline void copy(T*A,T*B,int l,int r)
{
    for(int i=l;i<=r;++i)
        A[i-l+1]=B[i];
}
struct block
{
    int n,pos,layer,now;
    bool created;
    int*f,*c;
    block()
    {
        created=now=0;
    }
    void init(int x,int where,int*A)
    {
        if(created)
            delete f,delete c;
        created=1;
        for(int i=1;i<=x;++i)
            wait_R[i]=A[i],wait_C[i]=0;
        sort(wait_R+1,wait_R+x+1);
        int size=0;
        for(int i=1;i<=x;++i)
        {
            if(wait_R[i]!=wait_R[i-1]||i==1)
                wait_W[++size]=wait_R[i];
            ++wait_C[size];
        }
        n=size;
        f=new int[n+2];
        c=new int[n+2];
        now=c[0]=f[0]=c[n+1]=f[n+1]=0;
        layer=where;
        pos=1;
        for(int i=1;i<=n;++i)
            f[i]=wait_W[i],c[i]=wait_C[i];
        while(f[pos]<layer)
            now+=c[pos],++pos;
    }
    inline int get()
    {
        return now;
    }
    inline void add()
    {
        if(layer+1==f[pos]+1)
            now+=c[pos],++pos;
        ++layer;
    }
    inline void remove()
    {
        if(pos&&layer-1==f[pos-1])
            now-=c[pos-1],--pos;
        --layer;
    }
};
struct sequence
{
    int*a,*tag,*bel,*tail;
    block*B;
    int n,sqr,tot;
    void init(int x,int*A)
    {
        n=x;
        sqr=sqrt(n+0.5);
        a=new int[n+3];
        bel=new int[n+3];
        tag=new int[sqr+3];
        tail=new int[sqr+3];
        for(int i=0;i<=sqr+1;++i)
            tail[i]=tag[i]=0;
        a[0]=0;
        for(int i=1;i<=n;++i)
            a[i]=A[i];
        int L=1,R=sqr;
        B=new block[sqr+3];
        tot=0;
        while(L<=n)
        {
            int len=min(n,R)-L+1;
            copy(wait,a,L,min(n,R));
            B[++tot].init(len,0,wait);
            for(int i=L;i<=R;++i)
                bel[i]=tot;
            tail[tot]=min(n,R);
            L+=sqr,R+=sqr;
        }
    }
    inline int get()
    {
        int sum=0;
        for(int i=1;i<=tot;++i)
            sum+=B[i].now;
        return sum;
    }
    inline void add(int x)
    {
        int i=1;
        for(i=1;bel[i]!=bel[x];i+=sqr)
            B[bel[i]].add();
        int L=i,R=tail[bel[x]];
        int len=R-L+1;
        for(int i=L;i<=R;++i)
            wait[i-L+1]=a[i]-B[bel[x]].layer;
        for(int i=L;i<=x;++i)
            --wait[i-L+1];
        for(int i=L;i<=R;++i)
            a[i]=wait[i-L+1];
        B[bel[x]].init(len,0,wait);
    }
    inline void remove(int x)
    {
        int i=1;
        for(i=1;bel[i]!=bel[x];i+=sqr)
            B[bel[i]].remove();
        int L=i,R=tail[bel[x]];
        int len=R-L+1;
        for(int i=L;i<=R;++i)
            wait[i-L+1]=a[i]-B[bel[x]].layer;
        for(int i=L;i<=x;++i)
            ++wait[i-L+1];
        for(int i=L;i<=R;++i)
            a[i]=wait[i-L+1];
        B[bel[x]].init(len,0,wait);
    }
    inline void addDot(int x,int y)
    {
        int i=1;
        while(bel[i]!=bel[x])
            i+=sqr;
        int L=i,R=tail[bel[x]];
        int len=R-L+1;
        for(int i=L;i<=R;++i)
            wait[i-L+1]=a[i]-B[bel[x]].layer;
        wait[x-L+1]+=y;
        for(int i=L;i<=R;++i)
            a[i]=wait[i-L+1];
        B[bel[x]].init(len,0,wait);
    }
}S[maxn];
///////////////////////////////////////////////////////////////////////////////
int n,q,a[maxn];
int size,head[maxn*2];
int sum[maxn],fa[maxn],son[maxn],top[maxn],where[maxn],dfn[maxn],low[maxn],ti;
int tot,ans;
bool c[maxn];
struct edge
{
    int to,next;
}E[maxn*2];
void dfs1(int u,int F)
{
    fa[u]=F,sum[u]=1;
    for(int i=head[u];i;i=E[i].next)
    {
        int v=E[i].to;
        if(v==F)
            continue;
        dfs1(v,u);
        sum[u]+=sum[v];
        if(sum[son[u]]<sum[v])
            son[u]=v;
    }
}
void dfs2(int u,int F)
{
    low[u]=dfn[u]=++ti;
    if(son[F]==u)
        top[u]=top[F];
    else
        top[u]=u;
    if(son[u])
    {
        dfs2(son[u],u);
        low[u]=low[son[u]];
    }
    for(int i=head[u];i;i=E[i].next)
    {
        int v=E[i].to;
        if(v==F||v==son[u])
            continue;
        dfs2(v,u);
        low[u]=low[v];
    }
}
void get(int u)
{
    wait[where[u]=++tot]=a[u];
    if(son[u])
        get(son[u]);
}
void add(int u,int v)
{
    E[++size].to=v;
    E[size].next=head[u];
    head[u]=size;
}
void addChain(int x)
{
    while(x)
    {
        S[top[x]].add(where[x]);
        x=fa[top[x]];
    }
}
void removeChain(int x)
{
    while(x)
    {
        S[top[x]].remove(where[x]);
        x=fa[top[x]];
    }
}
int askChain(int x)
{
    int sum=0;
    while(x)
    {
        sum+=S[top[x]].get();
        x=fa[top[x]];
    }
    return sum;
}
///////////////////////////////////////////////////////////////////////////////
int main()
{
    ios::sync_with_stdio(false);
    int num;
    cin>>num;
    cin>>n>>q;
    for(int i=2;i<=n;++i)
    {
        int x;
        cin>>x;
        add(x,i);
        add(i,x);
    }
    for(int i=1;i<=n;++i)
        cin>>a[i];
    dfs1(1,1);
    dfs2(1,1);
    fa[1]=0;
    for(int u=1;u<=n;++u)
        if(top[u]==u)
        {
            tot=0;
            get(u);
            S[u].init(tot,wait);
        }
    while(q--)
    {
        int x;
        cin>>x;
        if(c[x])
        {
            int last=askChain(x);
            removeChain(fa[x]);
            S[top[x]].addDot(where[x],-666666);
            int now=askChain(x);
            ans+=now-last;
        }
        else
        {
            int last=askChain(x);
            addChain(fa[x]);
            S[top[x]].addDot(where[x],666666);
            int now=askChain(x);
            ans+=now-last;
        }
        c[x]^=1;
        cout<<ans<<" ";
    }
    return 0;
}