数列分块总结——题目总版（hzwer分块九题及其他题目）（分块）

闲话

莫队算法似乎还是需要一点分块思想的。。。。。。于是我就先来搞分块啦！

膜拜hzwer学长神犇%%%Orz

这九道题，每一道都堪称经典，强力打Call！点这里进入

算法简述

每一次考试被炸得体无完肤之后，又听到讲题目的Dalao们爆出一句

数据不大，用分块暴力搞一下就AC了

的时候，我就会五体投地，不得翻身。。。。。。

分块？暴力？真的有如此玄学？

直到现在我还是觉得它很笨拙，但要熟练运用（尤其是打大暴力部分分的时候），绝非易事。

没错，分块是优化的暴力，更轻松地资瓷在线，是一种算法思想，主要用来维护区间信息，因此也可以当成数据结构。

当绞尽脑汁也无法发现能用自带log的数据结构（线段树，树状数组，平衡树······）维护的时候，一定不要抛弃它。

一般的分块题目形式，都是给你若干个区间处理操作。这些区间有长有短，直接暴力操作复杂度是\(O(n^2)\)的。

分块就是为了解决区间过长所导致的低效而出现的。

具体做法，是把数列分成若干个小块，每个小块内部，每个元素的值仍然需要维护，然后再维护整个小块的信息。

对于一个很长的操作区间，其内部一定会包含若干连续的小块对吧。

对这些小块，直接对小块信息操作，不用一个个操作每个元素啦，从而省去了大量时间。

当然，区间两头会有不包含一个完整小块的部分，暴力修改。然而这两头长度加起来不会超过块的长度的两倍，复杂度有保证。

常见题目类型&套路&难度分析（持续更新中）

1. 维护块信息总和★★☆☆☆
   
   最裸的一类啦。。。。。。
   
   例题有下面hzwer九题中的1、4

2. 维护块标记并进行懒处理★★★☆☆
   
   需要分析复杂度的思路，巧妙地利用题目特点，维护好懒标记并正确释放，但实现难度不高
   
   例题有下面hzwer九题中的5、7和8

3. 块内维护其它结构★★★☆☆
   
   思路较清晰，但实现难度加大，常见的类型(我只见过的)有
   
   —— 有序表，以便资磁块内二分答案等操作，如下面hzwer九题中的2、3
   
   —— 链表，可以方便地插入和删除，更可以高效完成块与块的合并或分裂（重构），如下面hzwer九题中的6
   
   —— 平衡树，更多高级操作，题目仍在发现中（当然，可以把hzwer九题中的3、6两题的操作合在一起）（手动滑稽）
   
   —— 。。。。。。

4. 维护块区间的信息★★★★☆
   
   解释一下，这里的“块区间”指的是第\(l\)个块到第\(r\)个块的信息。如果需要这样维护的话，通常思维难度和实现难度都上了一个档次。
   
   题目仍在发现并落实中。。。。。。（hzwer九题中的9当然是个火题辣，不过利用了离线我用常数更优的莫队水了一下）

题目列表

hzwer数列分块入门九题

hzwer的题解都很详细了，我再写点自己的东西吧。

分块入门 1 by hzwer

LOJ题目传送门

题面等于洛谷模板树状数组2。。。。。。

不过既然学分块就好好学嘛。

这里的小块信息就是一个加法标记，表示对整个区间的所有数加上标记值。

于是做法就很简单了。

对于这个分块长度（以下设为\(m\)）的问题，我不是很清楚。对于每个具体的题目，到底该取多少呢？

方便的话，默认\(m=\sqrt n\)吧。

分析一下单次修改的复杂度。在本题中，整块修改复杂度取决于块的数量，复杂度\(O({n\over m})\)；

不完整块暴力修改复杂度取决于块的长度，复杂度\(O(m)\)。

根据基本不等式，\({n\over m}+m≥2\sqrt n\)当且仅当\({n\over m}=m\)时等号成立。

于是\(m=\sqrt n\)。

当然，如果数据是随机的，那么平均情况下的系数考虑一下会得到更好的\(m\)。

首先，询问区间的平均长度是\(n\over 3\)（试出来的，我太弱了不会证，欢迎Dalao指教）

然后，暴力修改的部分平均长度肯定是\(m\)（\({m\over 2}×2\)），得到带系数的复杂度\(O({n\over {3m}}+m)\)。

再次用基本不等式得到更优的\(m\)是\(\sqrt{{n\over 3}}\)。

目测hzwer的数据是rand的，所以改了以后确实快不少。

贴下代码吧。貌似我的代码永远是最短最丑的。。。。。。

#include<cstdio>
#include<cmath>
int a[50009],b[233];//b为小块加法标记
int main()
{
	register int n,L,i,op,l,r,c;
	scanf("%d",&n);
	L=sqrt(n/3);
	for(i=0;i<n;++i)scanf("%d",&a[i]);
	for(i=0;i<n;++i)
	{
		scanf("%d%d%d%d",&op,&l,&r,&c);
		--l;--r;//为了方便，数组从0下标开始存了
		if(op)printf("%d\n",a[r]+b[r/L]);
		else
		{
			for(;l<=r&&l%L;++l)a[l]+=c;//暴力（左）
			for(;l+L-1<=r;l+=L)b[l/L]+=c;//改块
			for(;l<=r;++l)a[l]+=c;//暴力（右）
		}
	}
	return 0;
}

分块入门 2 by hzwer

LOJ题目传送门

这时候，分块成为了最优解法。

排序预处理，询问操作块内二分，块外暴力。

修改操作块内放加法标记，块外暴力加排序重构。

平均情况下复杂度大致为\(O(n\log m+n({n\over m}\log m+m\log m))\)

利用平均系数\(m\)同样可取\(\sqrt{{n\over 3}}\)

实际上我尝试了一下，\(\sqrt{{n\over 4}}\)即\(\sqrt n\over 2\)更快。

因为预处理中带了个\(m\)，加上修改操作中也带有\(m\)而在上式中为了简便被省略了。

所以\(m\)适当的更小一点。

还有一点，其实修改操作时对两个不完整部分的重新排序，可以不用写sort。

原块已经排好序，修改相当于给这个有序序列部分元素加上一个相等的值。

那么现在这个序列可以分成两个集合——被加的和没被加的。可以看出这两个集合按在原序列的位置中，仍然是各自有序的。

对两个有序的序列再排序，最高效的不就是二路归并吗？

这样做的话，要在有序序列中额外维护每个元素在原序列中的位置。

扫一遍这个不完整块的时候，根据位置判断是否被加，然后放入对应集合。最后对两个集合归并排序放回有序序列即可。

仅仅对单次修改操作而言，这样做使得复杂度降至\(O({n\over m}+m)\)，去掉了\(\log\)。

然而这种写法也有一点常数，也比较麻烦，我就偷了点懒QvQ

上代码

#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
using namespace std;
#define R register
char s[1314520];
int a[54250],b[54250],t[2333];//请忽略丑陋的数组长度定义
#define resort(P) {memcpy(b+P,a+P,L<<2);sort(b+P,b+P+L);}//重构排序
#define in(z) {while(*++p<'-');z=*p&15;while(*++p>'-')z*=10,z+=*p&15;}
int main(){
	fread(s,1,sizeof(s),stdin);
	R char*p=s-1;
	R int n,L,i,op,l,r,c,ans;
	in(n);
	L=sqrt(n)/2;
	for(i=0;i<n;++i)in(a[i]);
	for(;i%L;++i)a[i]=1e9;//人工在最末块尾部插入inf，避免vector带来的常数
	for(i=0;i<n;i+=L)resort(i);//初始化排序
	for(i=0;i<n;++i){
		in(op);in(l);in(r);in(c);
		--l;--r;
		if(op){
			ans=0;c*=c;
			for(;l<=r&&l%L;++l)ans+=a[l]+t[l/L]<c;//暴力（左）
			for(;l+L-1<=r;l+=L)ans+=lower_bound(b+l,b+l+L,c-t[l/L])-b-l;//块内二分统计答案
			for(;l<=r;++l)ans+=a[l]+t[l/L]<c;//暴力（右）
			printf("%d\n",ans);
		}
		else{
			if(l/L==r/L){//在同一个块中，暴力改完走人
				for(;l<=r;++l)a[l]+=c;
				resort(r/L*L);
				continue;
			}
			if(l%L){//暴力（左）
				for(;l%L;++l)a[l]+=c;
				resort(l-L);
			}
			for(;l+L-1<=r;l+=L)t[l/L]+=c;//直接改
			if(r>=l){//暴力（右）
				for(;r>=l;--r)a[r]+=c;
				resort(l);
			}
		}
	}
	return 0;
}

分块入门 3 by hzwer

LOJ题目传送门

基本思路与2差不多，除了二分统计答案的方式。

因此就没什么好说的啦，代码跟上面一样丑，就不贴了

分块入门 4 by hzwer

LOJ题目传送门

题面等于洛谷模板线段树1。。。。。。

相比1，再加上块内总和的维护就好啦，代码也不贴了

分块入门 5 by hzwer

LOJ题目传送门

其实分块不是正解，我还是惯性思维想到了线段树。

反正开方不会超过四次，那可以用带log的数据结构维护。

考虑线段树，弄个标记表示当前节点区间已全部变为0或1，假如两个子区间都打标记了，那么当前区间也打上，以后区间开方碰到有标记就结束掉。

这样复杂度是对的，\(O(N\log N)\)带上一个不小的常数，但总比分块好点。。。。。。

分块的话也就是在块内搞同样意义的标记嘛！似乎还要写链表，不是很轻松的暴力。。。。。。我还是太懒了

线段树代码（放在这里极其不和谐）

#include<cstdio>
#include<cmath>
#define R register
#define G c=getchar()
inline void in(R int&z){
	R char G;
	while(c<'-')G;
	z=c&15;G;
	while(c>'-')z*=10,z+=c&15,G;
}
const int M=3000000;
int le[M],mi[M],ri[M],s[M],t[M];
#define lc u<<1
#define rc u<<1|1
#define pushup s[u]=s[lc]+s[rc],t[u]=t[lc]&t[rc]//上传和以及标记
void build(R int u,R int l,R int r){//建树
	le[u]=l;ri[u]=r;mi[u]=(l+r)>>1;
	if(l==r){
		in(s[u]);
		if(s[u]<2)t[u]=1;
		return;
	}
	build(lc,l,mi[u]);
	build(rc,mi[u]+1,r);
	pushup;
}
void update(R int u,R int l,R int r){//更新，略超出模板范围
	if(t[u])return;
	if(le[u]==ri[u]){
		s[u]=sqrt(s[u]);
		if(s[u]<2)t[u]=1;
		return;
	}
	if(r<=mi[u])update(lc,l,r);
	else if(l>mi[u])update(rc,l,r);
	else update(lc,l,mi[u]),update(rc,mi[u]+1,r);
	pushup;
}
int ask(R int u,R int l,R int r){//查询完全是模板
	if(l==le[u]&&r==ri[u])return s[u];
	if(r<=mi[u])return ask(lc,l,r);
	else if(l>mi[u])return ask(rc,l,r);
	else return ask(lc,l,mi[u])+ask(rc,mi[u]+1,r);
}
int main(){
	R int n,op,l,r,c;
	in(n);
	build(1,1,n);
	while(n--){
		in(op);in(l);in(r);in(c);
		if(op)printf("%d\n",ask(1,l,r));
		else update(1,l,r);
	}
	return 0;
}

分块入门 6 by hzwer

LOJ题目传送门

总觉得像平衡树基本操作。。。。。。

这里引入了一个新的概念——重构。

为了方便，我手写了一下链表套链表（滑稽）

就是块与块之间用链表相连，块中的每个元素也用链表连起来。

我采用了区间过大重构的方法。

这样的话当区间过大时，直接新开一个块插入在块的链表中，再让其指向原块的中点位置元素，省了挺多事的。

查询的话就维护每个块的大小，从前往后扫，以此确定某点在哪一个块中，再在块内挨个找。

还有一个小小的idea，可以让靠前的块更大，靠后的块略小，复杂度被平均了，会降低一些（只是貌似带来了更大的常数。。。。。。）

代码

#include<cstdio>
#include<cmath>
#define G c=getchar()
#define in(z) G;\
	while(c<'-')G;\
	z=c&15;G;\
	while(c>'-')z*=10,z+=c&15,G
const int B=1009,N=200009;
int s[B],neb[B],he[B],ne[N],v[N];
//neb块链表，he块首元素，ne元素链表，注意区分
int main()
{
	register int n,L,i,j,b,p,pb,op,l,r;
	register char c;
	in(n);L=sqrt(n);
	for(b=i=j=0;i<n;++i,++j){
		in(v[i]);
		if(j==L){
			j=0;
			neb[b]=b+1;
			he[++b]=i;
		}
		ne[i]=i+1;
		++s[b];
	}
	p=n-1;pb=b;//p新点，pb新块
	while(n--){
		in(op);in(l);in(r);in(j);
		if(op){//查询，先扫块，再扫元素
			for(b=0;s[b]<r;r-=s[b],b=neb[b]);
			for(i=he[b],--r;r;i=ne[i],--r);
			printf("%d\n",v[i]);
		}
		else{
			for(b=0;s[b]<l;l-=s[b],b=neb[b]);
			if(--l){
				for(i=he[b],--l;l;i=ne[i],--l);
				ne[++p]=ne[i],ne[i]=p;
			}//找到插入位置并插入，注意特判块头
			else ne[++p]=he[b],he[b]=p;
			v[p]=r;
			if(++s[b]>=L<<1){//重构，把块砍两半
				s[++pb]=s[b]>>=1;
				neb[pb]=neb[b];neb[b]=pb;//神奇的链表指来指去
				for(i=he[b],l=L-1;l;i=ne[i],--l);
				he[pb]=ne[i];
			}
		}
	}
	return 0;
}

分块入门 7 by hzwer

LOJ题目传送门

题面等于洛谷模板线段树2（不是模板，是大火题！）

已经敲完线段树2和Tree II，对此题失去了兴趣（其实是因为我太弱了，真的怕放标记又写挂。。。。。。）

分块入门 8 by hzwer

LOJ题目传送门

思路像5，但代码不易，尤其是每次暴力左右不完整部分、破坏了块的同一个值的时候，还要释放标记，写起来是真心累。。。。。。

长长的代码

#include<cstdio>
#include<cmath>
#include<iostream>
using namespace std;
#define G ch=getchar()
#define in(z) G;\
	while(ch<'-')G;\
	z=ch&15;G;\
	while(ch>'-')z*=10,z+=ch&15,G
int a[100009],t[1009];
int main(){
	register int n,L,i,j,l,r,c,bel,ber,ans;
	register char ch;
	in(n);L=sqrt(n);
	for(i=0;i<n;++i){in(a[i]);}
	for(j=0;j<n;++j){
		in(l);in(r);in(c);--l;//所有下标减了1，并强行转化成左闭右开
		bel=l/L;ber=r/L;ans=0;
		//下面真的是一大堆讨论，为了减少代码量，把很多情况合并到一起处理了
		if(bel!=ber){
			if(l%L){//不完整（左）
				if(t[bel]){
					if(c==t[bel]){//与标记相等
						ans+=(bel+1)*L-l;l=(bel+1)*L;
						goto M;
					}
					for(i=bel*L;i<l;++i)a[i]=t[bel];//不相等，放标记
					t[bel]=0;
					for(i=l,l=(bel+1)*L;i<l;++i)a[i]=c;//暴力改
				}
				else for(i=l,l=(bel+1)*L;i<l;++i)
					a[i]==c?++ans:a[i]=c;//暴力
			}
			else --bel;
		  M:while(++bel<ber){//完整
				l+=L;
				if(t[bel]){
					if(c==t[bel]){
						ans+=L;
						continue;
					}
				}
				else for(i=l-L;i<l;++i)
						 a[i]==c?++ans:a[i]=c;
				t[bel]=c;//printf("bel%d ans%d\n",bel,ans);
			}
		}
		if(l==r)goto N;//无不完整（右）
		if(t[bel]){//在不完整的同一块中，或者不完整（右）
			if(c==t[bel]){
				ans+=r-l;
				goto N;
			}
			for(i=bel*L;i<l;++i)a[i]=t[bel];//两边都要放
			for(i=l;i<r;++i)a[i]=c;
			for(i=min((bel+1)*L,n)-1;i>=r;--i)a[i]=t[bel];
			t[bel]=0;
		}
		else for(i=l;i<r;++i)
			a[i]==c?++ans:a[i]=c;
	  N:printf("%d\n",ans);
	}
	return 0;
}

持续更新中。。。。。。