好久没写博客了哈，今天来水一篇。_(:з」∠)_
题目 ：弹飞绵羊（一道省选题）
题目描述
某天，Lostmonkey发明了一种超级弹力装置，为了在他的绵羊朋友面前显摆，他邀请小绵羊一起玩个游戏。游戏一开始，Lostmonkey在地上沿着一条直线摆上n个装置，每个装置设定初始弹力系数ki，当绵羊达到第i个装置时，它会往后弹ki步，达到第i+ki个装置，若不存在第i+ki个装置，则绵羊被弹飞。绵羊想知道当它从第i个装置起步时，被弹几次后会被弹飞。为了使得游戏更有趣，Lostmonkey可以修改某个弹力装置的弹力系数，任何时候弹力系数均为正整数。
输入输出格式
输入格式：
第一行包含一个整数n，表示地上有n个装置，装置的编号从0到n-1。
接下来一行有n个正整数，依次为那n个装置的初始弹力系数。
第三行有一个正整数m，
接下来m行每行至少有两个数i、j，若i=1，你要输出从j出发被弹几次后被弹飞，若i=2则还会再输入一个正整数k，表示第j个弹力装置的系数被修改成k。
输出格式：
对于每个i=1的情况，你都要输出一个需要的步数，占一行。
输入输出样例
输入样例#1：
4
1 2 1 1
3
1 1
2 1 1
1 1
输出样例#1：
2
3
说明
对于20%的数据n,m<=10000，对于100%的数据n<=200000,m<=100000
分析（1）
首先，本人拿到这篇题目的时候脑子是没有转过来的。那时候我在想什么呢？。。。对，当我们修改了某个点的k值之后，那么这个操作对于后面的点来说是没有丝毫的影响的，但却会使其前面的指向它的节点造成影响（因为一开始我没用分块嘛，直接用了一个比较暴力的思想：ans存答案，来做这道题的），于是乎觉得这样做太暴力，然后就弄了个懒标记和染色（但是有点复杂的样子于是乎挂了）。然后就直接一个朴素的懒标记骗了个50，TLE 五个点。
代码如下。
#include<bits/stdc++.h>
using namespace std;
const int M=2e5+100;
inline int read(){
int x=0; char c=getchar();
while(!isdigit(c)) c=getchar();
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
return x;
}
int n,m,tag;
int k[M],ans[M];
inline void dfs(int to){ //更新区间内节点的ans值
for(int i=tag-1;i>=to;--i)
ans[i]=ans[i+k[i]]+1;
}
int main(){
n=read();
for(int i=0;i<n;++i)
k[i]=read();
for(int i=n-1;i>=0;--i){
if(i+k[i]>=n) ans[i]=1;
else ans[i]=ans[i+k[i]]+1;
}
m=read();
while(m--){
int op=read();
if(op==1){
int now=read();
if(tag>now) dfs(now); //向前更新节点的ans值，直到当前的节点
printf("%d
",ans[now]);
}
else if(op==2){
int now=read(),nwk=read();
if(nwk==k[now]) continue;
if(tag>now) dfs(now); //原本的懒标记在后面那么先将now~tag的节点的ans值更新
tag=now; //懒标记记录下当前修改的位置
k[now]=nwk; int to=now+k[now];
if(to>=n) ans[now]=1;
else ans[now]=ans[to]+1;
}
}
return 0;
} 那么我们先不进行分块解法的讨论，首先看看一道简单的分块题来熟（复）悉（习）一下分块这个算法吧。（如果你是初学，请点这里）
Title ：A Simple Problem with Integers
Description
You have N integers, A1, A2, … , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.
//概述一下，就是区间加以及区间求和（简直就是模板题），另外提一下这个东西也可以用线段树做
Input
The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 1e5.
//表示有n（不超过1e5）个数字，Q（不超过1e5）个操作
The second line contains N numbers, the initial values of A1, A2, … , AN. -1e9 ≤ Ai ≤ 1e9.
//第二行有n个数字，都是int/2的范围内的（但是加起来是会爆int的）
Each of the next Q lines represents an operation.
//表示接下来Q行是Q个操作
“C a b c” means adding c to each of Aa, Aa+1, … , Ab. -1e4 ≤ c ≤ 1e4.
//C： 表示对a~b进行区间加操作
“Q a b” means querying the sum of Aa, Aa+1, … , Ab.
//Q： 表示询问a~b的区间和
Output
You need to answer all Q commands in order. One answer in a line. //回答询问，每行一个答案
Sample Input
10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4
Sample Output
4
55
9
15
Hint
The sums may exceed the range of 32-bit integers.
//可能会爆int（就是要你开long long）
代码如下：
#include<iostream>
#include<cmath>
#include<cstdio>
#include<math.h>
typedef long long ll;
using namespace std;
const int M=1e5+100;
inline ll read(){
ll x=0,f=1; char c=getchar();
for(;!isdigit(c);c=getchar()) if(c=='-') f=-1;
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
return x*f;
}
int n,q,block,num,l[M],r[M];
ll blg[M],a[M],d[M],sum[M];
inline void build(){ //建立分块
block=sqrt((double)n);
num=n/block; if(n%block) ++num;
for(int i=1;i<=num;++i)
l[i]=(i-1)*block+1,r[i]=i*block;
r[num]=n;
for(int i=1;i<=n;++i)
blg[i]=(i-1)/block+1,sum[blg[i]]+=a[i];
}
inline void update(int x,int y,int k){ //一个更新区间的操作
if(blg[x]==blg[y]){
sum[blg[x]]+=(y-x+1)*k;
for(int i=x;i<=y;++i)
a[i]+=k;
return ;
}
sum[blg[x]]+=(r[blg[x]]-x+1)*k;
sum[blg[y]]+=(y-l[blg[y]]+1)*k;
for(int i=x;i<=r[blg[x]];++i) a[i]+=k;
for(int i=l[blg[y]];i<=y;++i) a[i]+=k;
for(int i=blg[x]+1;i<blg[y];++i) d[i]+=k;
}
ll query(int x,int y){ //询问区间加的操作
ll ans=0;
if(blg[x]==blg[y]){
for(int i=x;i<=y;++i)
ans+=a[i]+d[blg[i]];
return ans;
}
for(int i=x;i<=r[blg[x]];++i) ans+=a[i]+d[blg[i]];
for(int i=l[blg[y]];i<=y;++i) ans+=a[i]+d[blg[i]];
for(int i=blg[x]+1;i<blg[y];++i) ans+=sum[i]+block*d[i];
return ans;
}
int main(){
n=read();q=read();
for(int i=1;i<=n;++i)
a[i]=read();
build();
while(q--){
char op=getchar();
while(!isupper(op)) op=getchar();
int L=read(),R=read();
if(op=='Q') printf("%lld
",query(L,R));
else update(L,R,read());
}
return 0;
}于是一道模板题热热身之后，大家应该有些分块思路了吧、？
分析（2）
于是乎该怎么办呢？（这个懒标记骗的分不满意啊）那么经过深思熟虑之后，我终于发现了这道题原来是可以用分块暴力来做的。具体怎么实现呢？其实就是说我们要维护某个点的话，就是维护他所在的那块区间里的值。什么值呢？ 第一个值是该节点跳出该区间所需的步数，第二个值是该节点跳出该区间后到达的下一个节点的位置（注意下一个节点不一定在该区间相邻的区间内）。于是乎这道题我就用个分块维护区间信息的方法A了此题。那么为什么用分块做效率较高呢？因为分块时我们对于区间的操作只有一个预处理（n）+分块询问、维护（m*sqrt(n)）的时间复杂度，即：O（n+m*sqrt(n)），这已经算是对于此问题一个较优的解法了（当然更优的还有动态树lct）。
代码如下：
#include<bits/stdc++.h>
using namespace std;
const int M=2e5+100;
inline int read(){ //快读
int x=0; char c=getchar();
while(!isdigit(c)) c=getchar();
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
return x;
}
int n,m,block,num;
int k[M],l[M],r[M],blg[M],ans[M],to[M];
inline void build(){ //建立分块区间
block=sqrt(n);
num=n/block; if(n%block) ++num;
for(int i=1;i<=num;++i)
l[i]=(i-1)*block+1,r[i]=i*block;
r[num]=n;
for(int i=1;i<=n;++i)
blg[i]=(i-1)/block+1;
}
inline void work(int x,int y){ //分块区间维护
for(int i=y;i>=x;--i){
int nxt=i+k[i];
(nxt>r[blg[i]])?
(ans[i]=1,to[i]=nxt):
(ans[i]=ans[nxt]+1,to[i]=to[nxt]);
}
}
inline int query(int now){ //单点询问
int res=ans[now],nxt=to[now];
for(int i=blg[now]+1;nxt<=n;++i)
res+=ans[nxt],nxt=to[nxt];
return res;
}
int main(){
n=read(); build();
for(int i=1;i<=n;++i)
k[i]=read();
work(1,n); //先维护一下整个区间
m=read();
while(m--){
int op=read();
if(op==1){
int now=read()+1;
printf("%d
",query(now));
}
else{
int now=read()+1,kk=read();
k[now]=kk;
work(l[blg[now]],r[blg[now]]); //这里只需维护单个分块区间
}
}
return 0;
}于是乎，这道题我们就可以愉快的用分块A了。
然后这道题貌似也没什么好说的了。。。那么，拜拜！ _(:з」∠)_
ヾ(￣▽￣)Bye~Bye~