bzoj 2002(分块)

bzoj 2002(分块)

转化后的题意：

给n个点，组成很多森林，每个点和父亲相连，父亲的编号比儿子大，两个操作

1.断掉某个点和父亲相连的边，将整颗子树接到另一个编号比他大的点

2.求i点在所在树的深度，根深度为1

这是很典型的树上问题，可以用LCT解决，这里我这样转化只是为了提醒自己以后遇到类似模型的时候可以尝试往序列分块上想，考虑转为序列问题，减少码量

思路：

假如没有断边接边操作，容易想到$O(n)$解法，考虑每次修改都暴力更新所有前面的点的答案，$O(n)$更新$O(1)$查询是我们无法承受的，但是答案之间是相关联的没必要一次性更新那么多，平衡一下复杂度。

分块，对于每个块，预处理块内元素跳出该块的步数，以及出去到的点，这样块内就独立了，修改的时候，只用暴力修改[L[x],x]]即可

总复杂度$O(n/B+B)$, $B=\sqrt{n}$的时候总复杂度为$q\sqrt{n}$

#include<bits/stdc++.h>
using namespace std;
const int maxn=2e5+5;
int n,m,big,num,L[maxn],R[maxn],pos[maxn],ans[maxn],res[maxn],a[maxn],op,x,k,cnt,tmp[maxn];
void init(){
    num=(n-1)/big+1;
    for(int i=1;i<=num;++i){
        L[i]=(i-1)*big+1;
        R[i]=i*big;
    }
    R[num]=n;
    for(int i=1;i<=num;++i){
        for(int j=L[i];j<=R[i];++j)
            pos[j]=i;
    }
    for(int i=n;i>=1;--i){
        if(i+a[i]>R[pos[i]]){
            ans[i]=1;
            res[i]=i+a[i];
        }else{
            ans[i]=ans[i+a[i]]+1;
            res[i]=res[i+a[i]];
        }
    }
}
int query(int x){
    int sum=0;  
    while(x<=n){
        sum+=ans[x];
        x=res[x];
    }
    return sum;
}
void update(int x,int k){
    a[x]=k;
    int pl=pos[x];
    for(int i=x;i>=L[pl];--i){
        if(i+a[i]>R[pl]){
            ans[i]=1;
            res[i]=i+a[i];
        }else{
            ans[i]=ans[i+a[i]]+1;
            res[i]=res[i+a[i]];
        }
    }
}
int main(){
    scanf("%d",&n);
    big=sqrt(n);
    for(int i=1;i<=n;++i)scanf("%d",&a[i]);
    init();
    scanf("%d",&m);
    for(int i=1;i<=m;++i){
        scanf("%d%d",&op,&x);
        x++;
        if(op==1){
            cout<<query(x)<<"\n";
        }else{
            scanf("%d",&k);
            update(x,k);
        }
    }
    return 0;
}