P3203 [HNOI2010]弹飞绵羊 —— 懒标记?分块?
好久没写博客了哈,今天来水一篇。_(:з」∠)_
题目 :弹飞绵羊(一道省选题)
题目描述
某天,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\n",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\n",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\n",query(now));
}
else{
int now=read()+1,kk=read();
k[now]=kk;
work(l[blg[now]],r[blg[now]]); //这里只需维护单个分块区间
}
}
return 0;
}
于是乎,这道题我们就可以愉快的用分块A了。
然后这道题貌似也没什么好说的了。。。那么,拜拜! _(:з」∠)_
ヾ( ̄▽ ̄)Bye~Bye~