bzoj 4911: [Sdoi2017]切树游戏

考虑维护原树的lct，在上面dp，由于dp方程特殊，均为异或卷积或加法，计算中可以只使用fwt后的序列

v[w]表示联通子树的最浅点为w，且不选w的splay子树中的点

l[w]表示联通子树的最浅点在w的lct子树中，且选w的splay子树中极左点（w的splay子树为{w}+{u的splay子树，满足u==ch[w][0]||u==ch[w][1]}）

r[w]表示联通子树的最浅点在w的lct子树中，且选w的splay子树中极右点

lr[w]表示联通子树的最浅点为w，且选w的splay子树中所有的点

s[w]表示联通子树的最浅点在w的lct子树中（w的lct子树为{w}+{u的lct子树，满足fa[u]==w}）

ss[w]表示联通子树的最浅点在w的lct子树中，且不选w

时间复杂度O((n+q)mlogm)，由于dp方程复杂以及lct自带的常数，总体常数较大

#include<bits/stdc++.h>
#define fm(i) for(int i=0;i<m;++i)
typedef int arr[];
const int N=,P=;
int n,m,v0[N],ivs[],*iv=ivs+P+;
arr x0[],ans,tmp;
std::vector<int>e[N];
struct node{
    node*c[],*f;
    arr v,vt,l,r,lr,s,ss;
    bool nrt();
    void up();
    void setrc(node*w);
}ns[N],*nil=ns,*rt=ns+;
void cpy(int*a,int*b){memcpy(a,b,sizeof(int)*m);}
bool node::nrt(){return this==f->c[]||this==f->c[];}
void node::up(){
    fm(i){
        int vi=vt[i]?:v[i];
        int vc0lr=vi*c[]->lr[i]%P;
        int vc0r=vi*c[]->r[i]%P;
        l[i]=(vc0lr*c[]->l[i]+c[]->l[i])%P;
        r[i]=(vc0r*c[]->lr[i]+c[]->r[i])%P;
        lr[i]=vc0lr*c[]->lr[i]%P;
        s[i]=(vc0r*c[]->l[i]+ss[i])%P;
    }
}
void mul(int*v1,int*t,int*v2){fm(i)v2[i]?v1[i]=v1[i]*v2[i]%P:++t[i];}
void div(int*v1,int*t,int*v2){fm(i)v2[i]?v1[i]=v1[i]*iv[v2[i]]%P:--t[i];}
void node::setrc(node*w){
    if(c[]!=nil)mul(v,vt,c[]->l);
    c[]=w;
    if(c[]!=nil)div(v,vt,c[]->l);
    up();
}
void rot(node*w){
    node*f=w->f,*g=f->f;
    int d=w==f->c[];
    if(f->nrt())g->c[g->c[]==f]=w;
    w->f=g;
    (f->c[d]=w->c[d^])->f=f;
    (w->c[d^]=f)->f=w;
    fm(i){
        int x=f->ss[i],y=f->c[d]->s[i];
        f->ss[i]=(x-w->s[i]+y)%P;
        w->s[i]=f->s[i];
        w->ss[i]-=y;
    }
    f->up();
    fm(i)w->ss[i]=(w->ss[i]+f->s[i])%P;
}
void sp(node*w){
    if(!w->nrt())return;
    do{
        node*f=w->f;
        if(f->nrt())rot((f->c[]==w)==(f->f->c[]==f)?f:w);
        rot(w);
    }while(w->nrt());
    w->up();
}
void acs(node*x){
    rt=x;
    for(node*y=nil;x!=nil;sp(x),x->setrc(y),y=x,x=x->f);
    sp(rt);
}
void dfs(int w,int pa){
    for(int i=;i<e[w].size();++i){
        int u=e[w][i];
        if(u!=pa){
            dfs(u,w);
            ns[u].f=ns+w;
            mul(ns[w].v,ns[w].vt,ns[u].l);
            fm(j)ns[w].ss[j]+=ns[u].s[j];
        }
    }
    ns[w].up();
}
void dwt(int*a){
    for(int i=;i<m;i<<=){
        for(int j=;j<m;j+=i<<){
            int*b=a+j,*c=b+i;
            for(int k=;k<i;++k){
                int x=b[k],y=c[k];
                b[k]=x+y;
                c[k]=x-y;
            }
        }
    }
    fm(i)a[i]%=P;
}
char buf[],*ptr=buf;
int _(){
    int x=;
    while(*ptr<)++ptr;
    while(*ptr>)x=x*+*ptr++-;
    return x;
}
int main(){
    fread(buf,,sizeof(buf),stdin);
    n=_();m=_();
    for(int i=;i<m;++i){
        x0[i][i]=;
        dwt(x0[i]);
    }
    iv[-P]=iv[]=;
    for(int i=;i<P;++i)iv[i-P]=iv[i]=(P-P/i)*iv[P%i]%P;
    for(int i=;i<=n;++i)ns[i]=(node){nil,nil,nil};
    cpy(nil->l,x0[]);
    cpy(nil->r,x0[]);
    cpy(nil->lr,x0[]);
    for(int i=;i<=n;++i){
        v0[i]=_();
        cpy(ns[i].v,x0[v0[i]]);
    }
    for(int i=,a,b;i<n;++i){
        a=_(),b=_();
        e[a].push_back(b);
        e[b].push_back(a);
    }
    dfs(,);
    for(int q=_(),ed=;q;--q){
        if(_()==){
            if(ed){
                cpy(ans,rt->s);
                dwt(ans);
                ed=;
            }
            printf("%d\n",(ans[_()]*iv[m]%P+P)%P);
        }else{
            ed=;
            int w=_(),x=_();
            acs(ns+w);
            int*v1=x0[v0[w]],*v2=x0[x];
            fm(i)rt->v[i]=rt->v[i]*v1[i][iv]%P*v2[i]%P;
            fm(i)ans[i]=rt->vt[i]?:rt->v[i];
            dwt(ans);
            v0[w]=x;
            rt->up();
        }
    }
    return ;
}

由于树形态不改变，也可以建一棵深度不超过logn+O(1)的静态lct，可以明显减小常数

#include<bits/stdc++.h>
#define fm(i) for(int i=0;i<m;++i)
typedef int arr[];
const int N=,P=;
int n,m,v0[N],ivs[],*iv=ivs+P+;
arr x0[],ans,tmp;
std::vector<int>e[N];
struct node{
    node*c[],*f;
    arr v,vt,l,r,lr,s,ss;
    bool isrt();
    void up();
}ns[N],*nil=ns,*rt;
bool node::isrt(){return this!=f->c[]&&this!=f->c[];}
void cpy(int*a,int*b){memcpy(a,b,sizeof(int)*m);}
void node::up(){
    fm(i){
        int vi=vt[i]?:v[i];
        int vc0lr=vi*c[]->lr[i]%P;
        int vc0r=vi*c[]->r[i]%P;
        l[i]=(vc0lr*c[]->l[i]+c[]->l[i])%P;
        r[i]=(vc0r*c[]->lr[i]+c[]->r[i])%P;
        lr[i]=vc0lr*c[]->lr[i]%P;
        s[i]=(vc0r*c[]->l[i]+ss[i])%P;
    }
}
void mul(int*v1,int*t,int*v2){fm(i)v2[i]?v1[i]=v1[i]*v2[i]%P:++t[i];}
void div(int*v1,int*t,int*v2){fm(i)v2[i]?v1[i]=v1[i]*iv[v2[i]]%P:--t[i];}
int fa[N],sz[N],son[N],dep[N],top[N],ws[N],wp;
void f1(int w,int pa){
    dep[w]=dep[fa[w]=pa]+(sz[w]=);
    for(int i=;i<e[w].size();++i){
        int u=e[w][i];
        if(u!=pa){
            f1(u,w);
            sz[w]+=sz[u];
            if(sz[u]>sz[son[w]])son[w]=u;
        }
    }
    ns[w].up();
}
node*build(int L,int R,node*f){
    if(L>R)return nil;
    int L0=L,R0=R;
    for(int M,s0=ws[L][sz]+ws[R+][sz];L<R;ws[M=L+R+>>][sz]*<s0?R=M-:L=M);
    node*w=ns+ws[L];
    w->c[]=build(L0,L-,w);
    w->c[]=build(L+,R0,w);
    w->f=f;
    w->up();
    if(f!=nil){
        fm(i)f->ss[i]+=w->s[i];
        if(L0==&&R0==wp)mul(f->v,f->vt,w->l);
    }
    return w;
}
void f2(int w,int tp){
    top[w]=tp;
    for(int i=;i<e[w].size();++i){
        int u=e[w][i];
        if(u!=fa[w]&&u!=son[w])f2(u,u);
    }
    if(son[w])f2(son[w],tp);
    else{
        wp=;
        for(int a=tp;a;a=son[a])ws[++wp]=a;
        ws[wp+]=;
        rt=build(,wp,ns+fa[tp]);
    }
}
void dwt(int*a){
    for(int i=;i<m;i<<=){
        for(int j=;j<m;j+=i<<){
            int*b=a+j,*c=b+i;
            for(int k=;k<i;++k){
                int x=b[k],y=c[k];
                b[k]=x+y;
                c[k]=x-y;
            }
        }
    }
    fm(i)a[i]%=P;
}
char buf[],*ptr=buf;
int _(){
    int x=;
    while(*ptr<)++ptr;
    while(*ptr>)x=x*+*ptr++-;
    return x;
}
int main(){
    fread(buf,,sizeof(buf),stdin);
    n=_();m=_();
    for(int i=;i<m;++i){
        x0[i][i]=;
        dwt(x0[i]);
    }
    iv[-P]=iv[]=;
    for(int i=;i<P;++i)iv[i-P]=iv[i]=(P-P/i)*iv[P%i]%P;
    for(int i=;i<=n;++i)ns[i]=(node){nil,nil,nil};
    cpy(nil->l,x0[]);
    cpy(nil->r,x0[]);
    cpy(nil->lr,x0[]);
    for(int i=;i<=n;++i){
        v0[i]=_();
        cpy(ns[i].v,x0[v0[i]]);
    }
    for(int i=,a,b;i<n;++i){
        a=_(),b=_();
        e[a].push_back(b);
        e[b].push_back(a);
    }
    f1(,);f2(,);
    for(int q=_(),ed=;q;--q){
        if(_()==){
            if(ed){
                cpy(ans,rt->s);
                dwt(ans);
                ed=;
            }
            printf("%d\n",(ans[_()]*iv[m]%P+P)%P);
        }else{
            ed=;
            int w=_(),x=_(),stp=;
            node*_w=ns+w,*stk[];
            for(node*a=_w;a!=nil;stk[++stp]=a,a=a->f);
            for(int i=stp;i>;--i){
                int*v1=stk[i]->ss,*v2=stk[i-]->s;
                fm(j)v1[j]-=v2[j];
                if(stk[i-]->isrt())div(stk[i]->v,stk[i]->vt,stk[i-]->l);
            }
            int*v1=x0[v0[w]],*v2=x0[x];
            fm(i)_w->v[i]=_w->v[i]*v1[i][iv]%P*v2[i]%P;
            _w->up();
            for(int i=;i<=stp;++i){
                int*v1=stk[i]->ss,*v2=stk[i-]->s;
                fm(j)v1[j]=(v1[j]+v2[j])%P;
                if(stk[i-]->isrt())mul(stk[i]->v,stk[i]->vt,stk[i-]->l);
                stk[i]->up();
            }
            v0[w]=x;
        }
    }
    return ;
}