[HNOI2010]弹飞绵羊

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

先建树，如果i+k大于n，就和n+1，建边表示弹出，否则和i+k建边

建树用LCT的link操作

修改就cut操作删掉旧边，加上新边

查询时，把n+1变为树根，把x到n+1都变为实根

查询路径上节点数-1输出

splay维护size，因为总是只有一颗完整的树，所以不需要判断cut和link操作的可行性

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 using namespace std;
 int size[],ch[][],rev[],pre[],isrt[],n,m,k[];
 void pushup(int o)
 {
   if (!o) return;
   size[o]=size[ch[o][]]+size[ch[o][]]+;
 }
 void pushdown(int o)
 {
   if (!o) return;
   if (rev[o])
     {
       int ls=ch[o][],rs=ch[o][];
       rev[ls]^=;
       swap(ch[ls][],ch[ls][]);
       rev[rs]^=;
       swap(ch[rs][],ch[rs][]);
       rev[o]=;
     }
 }
 void push(int o)
 {
   if (isrt[o]==) push(pre[o]);
   pushdown(o);
 }
 void rotate(int o,bool kind)
 {
   int p=pre[o];
   ch[p][!kind]=ch[o][kind];pre[ch[o][kind]]=p;
   if (isrt[p]) isrt[p]=,isrt[o]=;
   else ch[pre[p]][ch[pre[p]][]==p]=o;
   pre[o]=pre[p];
   ch[o][kind]=p;pre[p]=o;
   pushup(p);pushup(o);
 }
 void splay(int o)
 {
   push(o);
   while (isrt[o]==)
     {
       if (isrt[pre[o]])
     rotate(o,ch[pre[o]][]==o);
       else
     {
       int p=pre[o],kind=ch[pre[p]][]==p;
       if (ch[p][kind]==o)
         rotate(o,!kind),rotate(o,kind);
       else rotate(p,kind),rotate(o,kind);
     }
     }
 }
 void access(int o)
 {
   int y=;
   while (o)
     {
       splay(o);
       isrt[ch[o][]]=;
       isrt[ch[o][]=y]=;
       pushup(o);
       y=o;o=pre[o];
     }
 }
 void makeroot(int o)
 {
   access(o);
   splay(o);
   rev[o]^=;
   swap(ch[o][],ch[o][]);
 }
 void link(int x,int y)
 {
   makeroot(x);
   pre[x]=y;
 }
 void cut(int x,int y)
 {
   makeroot(x);
   access(y);splay(y);
   ch[y][]=;pre[x]=;
   isrt[x]=;
   pushup(y);
 }
 int main()
 {int i,c,x,y,st,ed;
   cin>>n;
   for (i=;i<=n+;i++)
     isrt[i]=,size[i]=;
   for (i=;i<=n;i++)
     {
       scanf("%d",&k[i]);
       if (i+k[i]>n) link(i,n+);
       else link(i,i+k[i]);
     }
   cin>>m;
   for (i=;i<=m;i++)
     {
       scanf("%d",&c);
       if (c==)
     {
       scanf("%d",&x);x++;
       makeroot(n+);
       access(x);
       splay(x);
       printf("%d\n",size[x]-);
     }
       else
     {
       scanf("%d%d",&x,&y);x++;
       if (k[x]+x>n) st=n+;
       else st=k[x]+x;
       if (y+x>n) ed=n+;
       else ed=y+x;
       k[x]=y;
       if (st!=ed)
         {
           cut(x,st);
           link(x,ed);
         }
     }
     }
 }

LCT

还有分块的做法

把n个点分成$sqrt n$块

预处理出f[i],s[i]

f[i]表示i会跳到下一块的地方

s[i]表示i跳到f[i]所需要的步数

查询时直接往后跳，最多跳$sqrt n$块

修改时只修改那一块$sqrt n$个元素

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 using namespace std;
 int n,k[],lim,s[],f[],m;
 int main()
 {int i,j,opt,x,now,cnt,y;
   cin>>n;
   for (i=;i<=n;i++)
     {
       scanf("%d",&k[i]);
     }
   lim=sqrt(n);
   for (i=;i<=n;i+=lim)
     {
       for (j=min(n,i+lim-);j>=i;j--)
     {
       if (k[j]+j>min(n,i+lim-)) s[j]=,f[j]=k[j]+j;
       else s[j]=s[j+k[j]]+,f[j]=f[k[j]+j];
     }
     }
   cin>>m;
   for (i=;i<=m;i++)
     {
       scanf("%d%d",&opt,&x);x++;
       if (opt==)
     {
       cnt=;
       while (x<=n)
         {
           cnt+=s[x];
           x=f[x];
         }
       printf("%d\n",cnt);
     }
       else
     {
       scanf("%d",&y);
       k[x]=y;
       if (x%lim==) now=x-lim+;
       else now=x-x%lim+;
       for (j=min(n,now+lim-);j>=now;j--)
         {
           if (k[j]+j>min(n,now+lim-)) s[j]=,f[j]=k[j]+j;
           else s[j]=s[j+k[j]]+,f[j]=f[k[j]+j];
         }
     }
     }
 }

分块