[BZOJ2002][HNOI2010]弹飞绵羊（LCT）

题目描述

传送门

题解

LCT模板题。
将每一个点连到能跳到的点，被弹飞的点连到n+1，那么就形成了一个树结构。
动态地在这棵树上维护就可以了。
询问的时候将那个点在辅助树中转到根，由于辅助树中splay按照深度关键字排序，所以根的左子树的大小就要要被弹几次了呀。

代码

#include
#include
#include
using namespace std;

const int max_n=2e5+5;

int n,m,x,y,opt;
int a[max_n];
int f[max_n],ch[max_n][2],size[max_n],reverse[max_n];
int strack[max_n];

inline int get(int x){
    return ch[ f[x] ][1]==x;
}

inline int Is_Root(int x){
    return ch[ f[x] ][0]!=x&&ch[ f[x] ][1]!=x;
}

inline void update(int x){
    if (x){
        size[x]=1;
        if (ch[x][0]) size[x]+=size[ ch[x][0] ];
        if (ch[x][1]) size[x]+=size[ ch[x][1] ];
    }
}

inline void pushdown(int x){
    if (x&&reverse[x]){
        swap(ch[x][0],ch[x][1]);
        if (ch[x][0]) reverse[ ch[x][0] ]^=1;
        if (ch[x][1]) reverse[ ch[x][1] ]^=1;
        reverse[x]=0;
    }
}

inline void rotate(int x){
    int old=f[x],oldf=f[old],which=get(x);

    if (!Is_Root(old))
      ch[oldf][ ch[oldf][1]==old ]=x;
    f[x]=oldf;

    ch[old][which]=ch[x][which^1];
    f[ ch[old][which] ]=old;

    ch[x][which^1]=old;
    f[old]=x;

    update(old);
    update(x);
}

inline void splay(int x){
    int top=0;
    strack[++top]=x;
    for (int i=x; !Is_Root(i); i=f[i])
      strack[++top]=f[i];
    for (int i=top; i>=1; --i) pushdown( strack[i] );

    for (int fa; !Is_Root(x); rotate(x))
      if (!Is_Root(fa=f[x]))
        rotate( (get(x)==get(fa)) ?fa:x);
}

inline void Access(int x){
    int t=0;
    for (; x; t=x,x=f[x]){
        splay(x);
        ch[x][1]=t;
    }
}

inline void Reverse(int x){
    Access(x);
    splay(x);
    reverse[x]^=1;
}

inline void Link(int x,int y){
    Reverse(x);
    f[x]=y;
    splay(x);
}

inline void Cut(int x,int y){
    Reverse(x);
    Access(y);
    splay(y);
    ch[y][0]=f[x]=0;
}

inline int Query(int x){
    Reverse(n+1);
    Access(x);
    splay(x);
    return size[ ch[x][0] ];
}

int main(){
    scanf("%d",&n);
    for (int i=1; i<=n; ++i){
        scanf("%d",&x);
        if (i+x<=n)
          a[i]=i+x;
        else
          a[i]=n+1;
        f[i]=a[i];
        size[i]=1;
    }
    size[n+1]=1;


    scanf("%d",&m);
    for (int i=1; i<=m; ++i){
        scanf("%d",&opt);
        if (opt==1){
            scanf("%d",&x);
            ++x;

            int ans=Query(x);
            printf("%d\n",ans);
        }
        else{
            scanf("%d%d",&x,&y);
            ++x; 
            Cut(x,a[x]);

            if (x+y<=n)
              a[x]=x+y;
            else
              a[x]=n+1;

            Link(x,a[x]); 
        }
    }
}

总结

LCT中的操作：
『Access操作』
目的：将x的重边切断，并将x到根的路径上所有的边都搞成重边。
具体实现：根据辅助树按照深度为关键字的性质，重建一颗splay。不断地将一个结点的父亲转到根，然后把这个结点接到它父亲的右儿子。
『Reverse操作』
目的：将原树中的x结点转到根。
具体实现：因为原树是虚树，所以在原树中进行变换实际上是在辅助树中进行变换。首先Access一个点，再将这个点在辅助树中转到根。又是根据辅助书按照深度为关键字的性质，将这个点所在的splay树反转，实际上改变了深度的关系，也就是实现的原树的换根。
『Link操作』
目的：将两个不连通的点连通。换句话来说，合并或扔到一颗树里。
具体实现：首先进行Reverse操作，在原树中将一个点转到那个点所在的树的根。然后将这个转到根的点的father接到另外一个点上。可以进行一次splay来update。
『Cut操作』
目的：将两个连通的点不连通，换句话说，把一棵树拆成两棵树。
具体实现：首先进行Reverse操作，在原树中将一个点转到那个点所在的树的根。然后Access另外一个点，把另外一个点在辅助树中转到根。由于这两个点原先是连通的，那么进行Access操作之后两个点在辅助树中一定是一个位于根，一个位于根的左儿子（深度）。所以在辅助树中把这个边砍掉就行了。
『Find操作』
目的：寻找一个点在原树中的根。
用于：判断两个点的连通性。
具体实现：首先Access这个点，然后在辅助树中将这个点转到根，由于辅助树按照深度为关键字排序，所以不断地向左子树寻找，就可以找到深度最小的根。

差不多就这些把，还有一些奇怪的求和啊，维护最大值最小值什么的和线段树平衡树等数据结构基本一样。也难怪，LCT其实就是线段树、平衡树的延伸。