ACM多校联赛7 2018 Multi-University Training Contest 7 1009 Tree

【题意概述】

　　给一棵以1为根的树，树上的每个节点有一个ai值，代表它可以传送到自己的ai倍祖先，如果不存在则传送出这棵树。现在询问某个节点传送出这棵树需要多少步。

【题解】

　　其实是把“弹飞绵羊”那道题从序列上搬到了树上，解法其实类似。

　　我们可以用LCT维护传送的关系，若点i存在ai倍祖先，那么就把他们link起来，否则就把i与特殊节点n+1给link起来。

　　询问某个点要传送多少次时，就是询问这个点到n+1有多远，我们在LCT上取出这一段，查询size即可。

 #include<cstdio>
 #include<algorithm>
 #include<cstring>
 #include<cmath>
 #define N (100010)
 #define ls (c[u][0])
 #define rs (c[u][1])
 #define LL long long
 #define rg register
 using namespace std;
 int T,n,m,opt,cnt,tot,last[N],k[N],dfn[N],dep[N],p[N][];
 struct edge{
     int to,pre;
 }e[N];
 char buf[],*ptr=buf-;
 template<typename T>
 inline void read(T &k)
 {
     int f=; k=; char c=*++ptr;
     while(c<'' || c>'') c=='-'&&(f=-), c=*++ptr;
     while(c<='' && c>='') k=k*+c-'', c=*++ptr;
     k*=f;
 }

 struct Link_Cut_Tree{
     int top,c[N][],fa[N],rev[N],size[N],q[N];
     inline void clear(){
         for(rg int i=;i<=n+;i++) c[i][]=c[i][]=size[i]=rev[i]=fa[i]=;
     }
     inline void pushdown(int u){
         if(rev[u]) rev[ls]^=,rev[rs]^=,rev[u]^=,swap(ls,rs);
     }
     inline void pushup(int u){
         size[u]=;
         if(ls) size[u]+=size[ls];
         if(rs) size[u]+=size[rs];
     }
     inline bool isroot(int u){
         return c[fa[u]][]!=u&&c[fa[u]][]!=u;
     }
     inline bool which(int u){
         return c[fa[u]][]==u;
     }
     void rotate(int u){
         int f=fa[u],gf=fa[f],wh=which(u);
         if(!isroot(f)) c[gf][which(f)]=u;
         fa[u]=gf; fa[f]=u; fa[c[u][wh^]]=f;
         c[f][wh]=c[u][wh^]; c[u][wh^]=f;
         pushup(f); pushup(u);
     }
     void splay(int u){
         q[top=]=u;
         for(int i=u;!isroot(i);i=fa[i]) q[++top]=fa[i];
         for(int i=top;i;i--) pushdown(q[i]);
         while(!isroot(u)){
             if(!isroot(fa[u])) rotate(which(u)==which(fa[u])?fa[u]:u);
             rotate(u);
         }
         pushup(u);
     }
     void access(int u){
         for(int son=;u;son=u,u=fa[u])
             splay(u),c[u][]=son,pushup(u);
     }
     void makeroot(int u){
         access(u); splay(u); rev[u]^=;
     }
     int find(int u){
         access(u); splay(u);
         while(ls) u=ls; splay(u);
         return u;
     }
     void split(int x,int y){
         makeroot(x); access(y); splay(y);
     }
     void cut(int x,int y){
         int xrt=find(x),yrt=find(y);
         if(xrt!=yrt) return;
         split(x,y);
         if(c[y][]==x) c[y][]=,fa[x]=;
         pushup(y);
     }
     void link(int x,int y){
         int xrt=find(x),yrt=find(y);
         if(xrt==yrt) return;
         makeroot(x); fa[x]=y;
     }
 }t;
 void dfs(int x,int fa){
     dfn[x]=++cnt; dep[x]=dep[fa]+; p[x][]=fa;
     int tmp=log2(dep[x]);
     for (int i=;i<=tmp;i++) p[x][i]=p[p[x][i-]][i-];
     for(rg int i=last[x];i;i=e[i].pre) dfs(e[i].to,x);
 }
 inline int anc(int x,int y){
     for(rg int i=;i<=;i++) if(y&(<<i)) x=p[x][i];
     return x;
 }
 inline void Pre(){
     for(rg int i=;i<=n;i++) last[i]=;
     cnt=tot=;
     t.clear();
 }
 int main(){
     fread(buf, , sizeof(buf), stdin);
     read(T);
     while(T--){
            read(n);
            Pre();
           for(rg int i=;i<=n;i++){
             int fa; read(fa);
                 e[++tot]=(edge){i,last[fa]}; last[fa]=tot;
         }
         dfs(,);
 //        for(rg int i=1;i<=n;i++) printf("%d ",dep[i]); puts("dep");
             for(rg int i=;i<=n;i++){
                 read(k[i]);
             if(k[i]>=dep[i]) t.link(dfn[i],n+);
             else t.link(dfn[i],dfn[anc(i,k[i])]);
         }
             read(m);
             while(m--){
                 int opt; read(opt);
                 if(opt==){
                     int x; read(x);
                     x=dfn[x];
                 t.makeroot(x); t.access(n+); t.splay(n+);
                 printf("%d\n",t.size[n+]-);
             }
             else{
                    int x,y; read(x); read(y);
                    if(k[x]>=dep[x]&&y>=dep[x]) continue;
                    if(k[x]>=dep[x]) t.cut(dfn[x],n+);
                 else t.cut(dfn[x],dfn[anc(x,k[x])]);
                 k[x]=y;
                 if(k[x]>=dep[x]) t.link(dfn[x],n+);
                 else t.link(dfn[x],dfn[anc(x,k[x])]);
             }
         }
     }
     return ;
 }