[Jzoj5157]没有上司的舞会

题意

在线的动态的《没有上司的舞会》$\Rightarrow$动态加点维护树的最大独立集,强制在线

---

题解

首先可以注意到每次加入一个点只会影响一条链上的$dp$值

考虑一下离线怎么做

考虑支持修改点权的带权最大独立集问题

考虑链上的情况:

建线段树,每个区间维护$f[1/0][1/0]$表示左端点选$/$不选,右端点选$/$不选的最优解

我们对每个重链维护一个这样的线段树,遇到轻边则暴力跳父亲更新即可

单次修改复杂度$O(\log^2n)$

套到这道题上,我们可以每次把一个点的权值由$0$修改为$1$,然后询问全局的带权最大独立集

总时间复杂度$O(n\log^2n)$

考虑在线怎么做

因为这棵树会动,并且要求的和树上路径无关,加上上面离线算法貌似能扩展到$LCT$上,所以应该是用$LCT$

所以对于每个点维护一下$dp[u][1/0][1/0]$表示$u$所在的$splay$区间的左右端点选不选

然后再去维护一下剩下的虚子树信息就好了,不会$LCT$维护子树信息可以先做一下模板[BJOI2014]大融合

其实就只要在$access$和$cut$的时候去操作一下就好了

#include<bits/stdc++.h>
#define fp(i,a,b) for(register int i=a,I=b+1;i<I;++i)
#define fd(i,a,b) for(register int i=a,I=b-1;i>I;--i)
#define go(u) for(register int i=fi[u],v=e[i].to;i;v=e[i=e[i].nx].to)
#define file(s) freopen(s".in","r",stdin),freopen(s".out","w",stdout)
template<class T>inline bool cmax(T&a,const T&b){return a<b?a=b,1:0;}
template<class T>inline bool cmin(T&a,const T&b){return a>b?a=b,1:0;}
using namespace std;
char ss[1<<17],*A=ss,*B=ss;
inline char gc(){return A==B&&(B=(A=ss)+fread(ss,1,1<<17,stdin),A==B)?-1:*A++;}
template<class T>inline void sd(T&x){
    char c;T y=1;while(c=gc(),(c<48||57<c)&&c!=-1)if(c==45)y=-1;x=c-48;
    while(c=gc(),47<c&&c<58)x=x*10+c-48;x*=y;
}
char sr[1<<21],z[20];int C=-1,Z;
inline void Ot(){fwrite(sr,1,C+1,stdout),C=-1;}
template<class T>inline void we(T x){
    if(C>1<<20)Ot();if(x<0)sr[++C]=45,x=-x;
    while(z[++Z]=x%10+48,x/=10);
    while(sr[++C]=z[Z],--Z);sr[++C]='\n';
}
const int N=3e5+5;
typedef long long ll;
typedef int arr[N];
struct LCT{
    int ch[N][2],fake[N][2],dp[N][2][2];arr fa;
    #define lc(x) (ch[x][0])
    #define rc(x) (ch[x][1])
    inline bool gf(int u){return rc(fa[u])==u;}
    inline bool ir(int u){return lc(fa[u])!=u&&rc(fa[u])!=u;}
    inline void up(int u){
        int l=lc(u),r=rc(u);
        if(!l&&!r){
            dp[u][0][1]=dp[u][1][0]=0;
            dp[u][1][1]=fake[u][1]+1;
            dp[u][0][0]=fake[u][0];
            return;
        }
        if(l&&r)fp(a,0,1)fp(b,0,1)
            dp[u][a][b]=max(dp[l][a][0]+fake[u][1]+dp[r][0][b]+1,max(dp[l][a][0],dp[l][a][1])+fake[u][0]+max(dp[r][0][b],dp[r][1][b]));
        else{
            if(l)fp(a,0,1){
                dp[u][a][1]=dp[l][a][0]+fake[u][1]+1;
                dp[u][a][0]=max(dp[l][a][0],dp[l][a][1])+fake[u][0];
            }         
            else fp(b,0,1){
                dp[u][1][b]=dp[r][0][b]+fake[u][1]+1;
                dp[u][0][b]=fake[u][0]+max(dp[r][0][b],dp[r][1][b]);
            }
        }
    }
    inline void rot(int u){
        int p=fa[u],k=gf(u);
        if(!ir(p))ch[fa[p]][gf(p)]=u;
        if(ch[u][!k])fa[ch[u][!k]]=p;
        ch[p][k]=ch[u][!k],ch[u][!k]=p;
        fa[u]=fa[p],fa[p]=u,up(p);
    }
    void splay(int u){
        for(int f=fa[u];!ir(u);rot(u),f=fa[u])
            if(!ir(f))rot(gf(u)==gf(f)?f:u);
        up(u);
    }
    inline void acc(int u){
        for(int v=0;u;u=fa[v=u]){
            splay(u);int w=rc(u);
            fake[u][0]+=max(max(dp[w][0][0],dp[w][0][1]),max(dp[w][1][0],dp[w][1][1]))
                -max(max(dp[v][0][0],dp[v][0][1]),max(dp[v][1][0],dp[v][1][1]));
            fake[u][1]+=max(dp[w][0][0],dp[w][0][1])-max(dp[v][0][0],dp[v][0][1]);
            rc(u)=v;up(u);
        }
    }
}t;
int n,ans,ty;
int main(){
    // #ifndef ONLINE_JUDGE
        file("party");
    // #endif
    sd(n);sd(ty);t.dp[1][1][1]=1;
    fp(i,2,n+1){
        int x;sd(x);x=(x^(ty*ans))+1;
        t.fa[i]=x;t.acc(x);t.splay(x);
        t.dp[i][1][1]=1;++t.fake[x][0];t.up(x);
        fp(a,0,1)fp(b,0,1)cmax(ans,t.dp[x][a][b]);
        we(ans);
    }
return Ot(),0;
}