【HYSBZ2002】LCT模板 Bounce 弹飞绵羊(一般题)

Description

某天，Lostmonkey发明了一种超级弹力装置，为了在他的绵羊朋友面前显摆，他邀请小绵羊一起玩个游戏。游戏一开始，Lostmonkey在地上沿着一条直线摆上n个装置，每个装置设定初始弹力系数ki，当绵羊达到第i个装置时，它会往后弹ki步，达到第i+ki个装置，若不存在第i+ki个装置，则绵羊被弹飞。绵羊想知道当它从第i个装置起步时，被弹几次后会被弹飞。为了使得游戏更有趣，Lostmonkey可以修改某个弹力装置的弹力系数，任何时候弹力系数均为正整数。

Input

第一行包含一个整数n，表示地上有n个装置，装置的编号从0到n-1,接下来一行有n个正整数，依次为那n个装置的初始弹力系数。第三行有一个正整数m，接下来m行每行至少有两个数i、j，若i=1，你要输出从j出发被弹几次后被弹飞，若i=2则还会再输入一个正整数k，表示第j个弹力装置的系数被修改成k。对于20%的数据n,m<=10000，对于100%的数据n<=200000,m<=100000

Output

对于每个i=1的情况，你都要输出一个需要的步数，占一行。

Sample Input

4
1 2 1 1
3
1 1
2 1 1
1 1

Sample Output

2
3

Solution

$Link-Cut-Tree$ 的模板题，当然这个模板没有那么裸，操作也没有那么多啦……
话说$LCT$确是一个很恶心的板子，我曾以为平衡树就是极致的恶心了，没想到$LCT$刷新了我对代码的印象的上界（曾经是二逼平衡树），但是弹飞绵羊不是很长（$130$左右），真正恶心的板子在这里
$Sone1$
还没写，估计有$200+$

回到弹飞绵羊，我们可以定义一个虚拟节点$n+1$，表示被弹飞。而如果节点$i$能够弹到$j$（弹飞就设为$n+1$），就将$i$设为$j$的儿子。因为每个$i$都只有一个父亲，并且它的父亲编号一定比$i$大，最终都会汇向$n+1$，所以可以发现，这其实是一棵有根树。

那么显然，修改操作就是修改父亲，查询操作就是查询深度。而修改父亲和查询深度都是$LCT$很拿手的，我们就这样做出来了。

$PS:$查询深度时，先$Access(x)$，让$n+1$到$x$变成一棵$Splay$，然后$Splay(x)$，让$x$变成根，这时$size[x]-1$就是$x$的深度了，所以还要维护一个$size$数组

然后就是代码了，这次加了注释，就可以看懂了~

#include<cstdio>
#include<cctype>
#include<cstring>
#include<algorithm>
using namespace std;
#define N 200005
int n,m,K[N];
char S[10];
namespace LCT
{
    int cnt,ch[N][2],fa[N],dt[N],siz[N];
    bool rv[N],tp[N];
    //节点个数 儿子 父亲 翻转懒标记 数据 是否为根
    inline void Push_Down(int x)//懒标记下传
    {
        if(rv[x])
        {
            rv[x]=0;
            swap(ch[x][0],ch[x][1]);
            if(ch[x][0])rv[ch[x][0]]^=1;
            if(ch[x][1])rv[ch[x][1]]^=1;
        }
    }
    inline void Push_Up(int x)//标记上传
    {
        siz[x]=siz[ch[x][0]]+siz[ch[x][1]]+1;
    }
    inline void Rotate(int x)//万能旋转
    {
        int y=fa[x],z=fa[fa[x]];
        if(!y||tp[x])return;
        int wh=(x==ch[y][1]);
        Push_Down(x);
        ch[y][wh]=ch[x][!wh];
        if(ch[y][wh])fa[ch[y][wh]]=y;
        ch[x][!wh]=y;
        fa[y]=x;
        if(!tp[y])ch[z][y==ch[z][1]]=x;
        fa[x]=z;
        tp[x]=tp[y],tp[y]=0;
        rv[x]=rv[y],rv[y]=0;
        Push_Up(y);
    }
    inline void Splay(int x)//翻转至根
    {
        Push_Down(x);Push_Up(x);
        for(;!tp[x];Rotate(x))
        {
            int y=fa[x];
            if(!tp[y])
            {
                int z=fa[y];
                if((x==ch[y][1])==(y==ch[z][1]))Rotate(y);
                else Rotate(x);
            }
        }
        Push_Down(x);Push_Up(x);
    }
    inline int Access(int x)//LCT的象征
    {
        int last=0;
        while(x)
        {
            Splay(x);
            if(ch[x][1])tp[ch[x][1]]=1;
            ch[x][1]=last;
            if(last)tp[last]=0;
            Push_Up(x);
            last=x;
            x=fa[x];
        }
        return last;
    }
    inline void Beroot(int x)//换根
    {
        Access(x);
        Splay(x);
        rv[x]^=1;
        Push_Down(x);
        Push_Up(x);
    }
    inline void Link(int u,int v)//链接(u->v)
    {
        Beroot(u);
        Access(v);
        fa[u]=v,tp[u]=1;
    }
    inline void Cut(int u,int v)//删除(u->v)
    {
        Beroot(u);
        Splay(v);
        if(fa[v]==u)
            fa[v]=0;
        else
            fa[u]=ch[v][0]=0,tp[u]=1;
        Push_Up(v);Push_Up(u);
        Push_Up(v);Push_Up(u);
    }
    inline void Link_Cut(int u,int v,int w)//删除(u->v)并链接(u->w)
    {
        Cut(u,v);
        Link(u,w);
    }
    inline int Find_Root(int x)//找根
    {
        Access(x);
        Splay(x);
        while(ch[x][0])
        {
            Push_Down(x);
            x=ch[x][0];
        }
        return x;
    }
    inline bool Query_Linked(int u,int v)//判断是否连通
    {
        return Find_Root(u)==Find_Root(v);
    }
    inline int Query_Deep(int x)//求深度
    {
        Access(x);
        Splay(x);
        return siz[x]-1;
    }
    inline void Init(int n)//初始化
    {
        cnt=n;
        memset(ch,0,sizeof(ch));
        memset(fa,0,sizeof(fa));
        memset(dt,0,sizeof(dt));
        memset(tp,1,sizeof(tp));
        memset(rv,0,sizeof(rv));
        for(int i=1;i<=n;i++)
            siz[i]=1;
    }
}
int Read()
{
    int p=0;char c=getchar();
    while(c>'9'||c<'0')c=getchar();
    while(c>='0'&&c<='9')p=p*10+c-'0',c=getchar();
    return p;
}
void Solve()
{
    for(int i=1;i<=m;i++)
    {
        int opt;
        opt=Read();
        if(opt==1)
        {
            int p=Read();
            printf("%d\n",LCT::Query_Deep(p+1));
        }
        else
        {
            int a=Read(),b=Read();
            a++;
            LCT::Link_Cut(a,min(a+K[a],n+1),min(a+b,n+1));
            LCT::Beroot(n+1);
            K[a]=b;
        }
    }
}
void Init()
{
    n=Read();
    LCT::Init(n+1);
    for(int i=1;i<=n;i++)
    {
        K[i]=Read();
        LCT::Link(i,min(i+K[i],n+1));
    }
    LCT::Beroot(n+1);
    m=Read();
}
int main()
{
    Init();
    Solve();
}