分块【2023.2.1】

一.引入

没有引入就是最好的引入

$——鲁迅$

为了骗分,$OIer$们研发出了$\mathcal{O}(n\sqrt{n})$的算法——分块¹(我不会说是我想不出来引入

二.算法介绍

分块$——$优雅的暴力

$——cqbzlhy$

三.算法实现

在2009年的你面前有一道灰题²：

有一段连续的序列$a_1$ ~ $a_n$，然后现在我们需要执行几类操作：

（一）1 l r:求出$[l,r]$ 区间的和

你心里大喜，一看就是前缀和，记录${\sum }_{k=1}^i{a}_k$为$su{m}_i$，然后显然有$su{m}_{i+1}=su{m}_i+a_{i+1}$，我们要求${\sum }_{i=l}^r{a}_i$就直接输出$su{m}_r-su{m}_{l-1}$呗，就一道黄题怎么会是灰题呢？

（二）2 l r x:将$[l,r]$区间加上$x$

你微微一愣,但是你会一种叫线段树³的数据结构$!!1$, 完全可以水掉这道题.

（三）3 l r x:在$[l,r]$这个区间中,查询小于$x$的前驱（比其小的最大元素）。

你暗暗吃惊,然后发现平衡树⁴可以水掉这道题.

数据范围:空间限制:$4MB$, 时间限制：1500 ms, 对于$100\%$的数据,$1\le n\le 10^5$(我们万恶的竞赛教练就是这么出的

你…倒在了电脑前,被一道小小的灰题打败了。

你不知道的是，一年后的莫涛队长（被尊称为莫队）发明了两种算法（莫队和分块，完美的解决了此类问题）

分块，顾名思义，就是把一段序列分成一小块一小块来处理，维护。

我们把一段当成一个整体，只记录维护整体的有关信息，就是分块。

首先，对于前言说得那道题，很朴素的做法就是：

1.从询问区间的l到r扫过去，每回加上扫到的值，即$ans={\sum }_{i=l}^r{a}_i$

2.直接把$a_i$重新赋值不就得了 $a_i+=x(l\le i\le r)$;

3.从询问区间的$l$到$r$扫过去,每回遇到$<x$的位置，答案记录最大值

代码:

while(q --){
	int opt, l, r, x;
	read(opt), read(l), read(r);
	if(opt == 1){
		int sum = 0;
		for(int i = l; i <= r; i ++)sum += a[i];
		write(sum);
		putchar('\n');
	}
	else if(opt == 2)for(int i = l; i <= r; i ++)a[i] += x;
	else{
		int res = 0;
		for(int i = l; i <= r; i ++)
			if(a[i] < k)res = max(a[i], res);
		write(res);
		putchar('\n');
	}
}

没错，这种做法很傻对不对？(我可能是真的傻子,这代码都写
但是，分块就是在这个基础上暴力优化的！！！
假设我们总共的序列长度为$n$，然后我们把它切成$\sqrt{n}$块，然后把每一块里的东西当成一个整体来看
1.如何得出答案：

$(1)$对于完整的块⁵，每个块需要有$sum$ 数组要维护这个块的所有元素的和。

$(2)$对于不完整块⁶，因为元素比较少(最多有$n$ / 块数 = $\sqrt{n}$个) 即使是极限数据：$n=100000$的时候也最多有$317$个而外面是$\mathcal{O}(n)$, 所以是不会超的。综上，我们可以直接暴力扫这个小块统计答案，

2.如何区间修改：

这里，我们换种思路，**记录一个$lazy$**标记(由线段树启发得到),表示整个块被加上过多少了，

$(1)$对于完整块，因为每个元素都被加上了$x$, 我们直接$lazy+=x$,块内的和$ans+=x\ast block$(元素个数);

$(2)$对于不完整块，直接暴力修改就好了，顺便可以把$lazy$标记清$0$。

3.如何求$x$的前驱：

$(1)$要求一个数的前驱，显然我们要求块内元素是有序的，这样就能用$lower\_bound$⁷对块内查询.

$(2)$不完整的块暴力就好, 这样的话需要提前对每块里面的元素做一遍排序就好, 但是当有修改的话，因为整个块同时加上(减去)一个数，每个数的相对大小是不会变的，但是如果是不完全块就会改变，这样的话，还是因为元素个数小，重新新排一下不就得了?

然后，这道题就用了一种看似高大上的方法做完了……比之前傻傻的暴力是不是好看很多呢

代码是例题三的哦~~:

四.例题

1.数列分块入门 1

思路:

1.如何得出答案：

输出$a_i+lazy$标记

2.如何区间修改：

**记录一个$lazy$**标记(由线段树启发得到),表示整个块被加上过多少了

$(1)$对于完整块，因为每个元素都被加上了$x$, 我们直接$lazy+=x$,块内的和$ans+=x\ast block$(元素个数);

$(2)$对于不完整块，直接暴力修改就好了，顺便可以把$lazy$标记清$0$。

代码:

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e4 + 5;
#define bl belong[ql]
#define br belong[qr]
int n, block, len, a[MAXN], lazy[MAXN], belong[MAXN], l[MAXN], r[MAXN];
template<typename T>
void read(T &x){
	x = 0;
	T f = 1;
	char ch = getchar();
	while(ch > '9' || ch < '0'){
		if(ch == '-')f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9'){
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	x *= f;
}
template<typename T>
void write(T x){
	if(x < 0){
		putchar('-');
		x = -x;
	}
	if(x >= 10)write(x / 10);
	putchar(x % 10 + 48);
}
void init(){
	block = sqrt(n);
	len = n / block + (n % block != 0);
	for(int i = 1; i <= n; i ++)belong[i] = (i - 1) / block + 1;
	for(int i = 1; i <= len; i ++)l[i] = (i - 1) * block + 1, r[i] = i * block;
	r[len] = n;
}
void update(int ql, int qr, int x){
	if(bl == br){
		for(int i = ql; i <= qr; i ++)a[i] += x;
		return ;
	}
	for(int i = bl + 1; i < br; i ++)lazy[i] += x;
	for(int i = ql; i <= r[bl]; i ++)a[i] += x;
	for(int i = l[br]; i <= qr; i ++)a[i] += x;
}
int query(int x){
	return a[x] + lazy[belong[x]];
}
int main(){
	read(n);
	for(int i = 1; i <= n; i ++)read(a[i]);
	init();
	for(int i = 1; i <= n; i ++){
		int opt, l, r, x;
		read(opt), read(l), read(r), read(x);
		if(opt == 0)update(l, r, x);
		else {
			write(query(r));
			putchar('\n');
		}
	}
	return 0;
}

2.数列分块入门 2

思路

1.如何区间修改：

这里，我们换种思路，**记录一个$lazy$**标记(由线段树启发得到),表示整个块被加上过多少了，

$(1)$对于完整块，因为每个元素都被加上了$x$, 我们直接$lazy+=x$,块内的和$ans+=x\ast block$(元素个数);

$(2)$对于不完整块，直接暴力修改就好了，顺便可以把$lazy$标记清$0$。

2.如何求$[l,r]$区间内小于$x^2$的个数：

$(1)$要求小于$x^2$的个数，显然我们要求块内元素是有序的，这样就能用$lower\_bound$⁷对块内查询,

输出$lower\_bound$传回的地址减去$l_i$(当前块的左端点)

$(2)$不完整的块暴力就好, 这样的话需要提前对每块里面的元素做一遍排序就好, 但是当有修改的话，因为整个块同时加上(减去)一个数，每个数的相对大小是不会变的，但是如果是不完全块就会改变，这样的话，还是因为元素个数小，重新新排一下不就得了?

代码

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e4 + 5;
#define bl belong[ql]
#define br belong[qr]
int n, block, len, a[MAXN], lazy[MAXN], belong[MAXN], l[MAXN], r[MAXN], b[MAXN];
template<typename T>
void read(T &x) {
	x = 0;
	T f = 1;
	char ch = getchar();
	while (ch > '9' || ch < '0') {
		if (ch == '-')f = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	x *= f;
}
template<typename T>
void write(T x) {
	if (x < 0) {
		putchar('-');
		x = -x;
	}
	if (x >= 10)write(x / 10);
	putchar(x % 10 + 48);
}
void init() {
	block = sqrt(n);
	len = n / block + (n % block != 0);
	for (int i = 1; i <= n; i ++) {
		belong[i] = (i - 1) / block + 1;
		b[i] = a[i];
	}
	for (int i = 1; i <= len; i ++) {
		l[i] = (i - 1) * block + 1, r[i] = min(i * block, n);
		sort(b + l[i], b + r[i] + 1);
	}
}
void update(int ql, int qr, int x) {
	if (bl == br) {
		for (int i = ql; i <= qr; i ++) a[i] += x;
		for (int i = l[bl]; i <= r[br]; i ++) b[i] = a[i];
		sort(b + l[bl], b + r[br] + 1);
		return ;
	}
	for (int i = bl + 1; i < br; i ++) lazy[i] += x;
	for (int i = ql; i <= r[bl]; i ++) a[i] += x;
	for (int i = l[bl]; i <= r[bl]; i ++)b[i] = a[i];
	sort(b + l[bl], b + r[bl] + 1);
	for (int i = l[br]; i <= qr; i ++) a[i] += x;
	for (int i = l[br]; i <= r[br]; i ++) b[i] = a[i];
	sort(b + l[br], b + r[br] + 1);
}
int query(int ql, int qr, int x) {
	int res = 0;
	if (bl == br) {
		for (int i = ql; i <= qr; i ++) res += (x > (a[i] + lazy[bl]));
		return res;
	}
	for (int i = bl + 1; i < br; i ++) res += lower_bound(b + l[i], b + r[i] + 1, x - lazy[i]) - b - l[i];
	for (int i = ql; i <= r[bl]; i ++) res += (x > (a[i] + lazy[bl]));
	for (int i = l[br]; i <= qr; i ++) res += (x > (a[i] + lazy[br]));
	return res;
}
int main() {
	read(n);
	for (int i = 1; i <= n; i ++) read(a[i]);
	init();
	for (int i = 1; i <= n; i ++) {
		int opt, l, r, x;
		read(opt), read(l), read(r), read(x);
		if (opt == 0) update(l, r, x);
		else {
			write(query(l, r, x * x));
			putchar('\n');
		}
	}
	return 0;
}

3.数列分块入门 3

思路

在算法介绍中

代码

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
#define bl belong[ql]
#define br belong[qr]
int n, block, len, a[MAXN], lazy[MAXN], belong[MAXN], l[MAXN], r[MAXN], b[MAXN];
template<typename T>
void read(T &x) {
	x = 0;
	T f = 1;
	char ch = getchar();
	while (ch > '9' || ch < '0') {
		if (ch == '-')f = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	x *= f;
}
template<typename T>
void write(T x) {
	if (x < 0) {
		putchar('-');
		x = -x;
	}
	if (x >= 10)write(x / 10);
	putchar(x % 10 + 48);
}
void init() {
	block = sqrt(n);
	len = n / block + (n % block != 0);
	for (int i = 1; i <= n; i ++) {
		belong[i] = (i - 1) / block + 1;
		b[i] = a[i];
	}
	for (int i = 1; i <= len; i ++) {
		l[i] = (i - 1) * block + 1, r[i] = min(i * block, n);
		sort(b + l[i], b + r[i] + 1);
	}
}
void update(int ql, int qr, int x) {
	if (bl == br) {
		for (int i = ql; i <= qr; i ++) a[i] += x;
		for (int i = l[bl]; i <= r[br]; i ++) b[i] = a[i];
		sort(b + l[bl], b + r[br] + 1);
		return ;
	}
	for (int i = bl + 1; i < br; i ++) lazy[i] += x;
	for (int i = ql; i <= r[bl]; i ++) a[i] += x;
	for (int i = l[bl]; i <= r[bl]; i ++) b[i] = a[i];
	sort(b + l[bl], b + r[bl] + 1);
	for (int i = l[br]; i <= qr; i ++) a[i] += x;
	for (int i = l[br]; i <= r[br]; i ++) b[i] = a[i];
	sort(b + l[br], b + r[br] + 1);
}
int query(int ql, int qr, int x) {
	int res = -1;
	if (bl == br) {
		for (int i = ql; i <= qr; i ++) 	
			if (a[i] + lazy[bl] < x && a[i] + lazy[bl] > res) res = a[i] + lazy[bl];
		return res;
	}
	for (int i = bl + 1; i < br; i ++) {
		int t = lower_bound(b + l[i], b + r[i] + 1, x - lazy[i]) - (b + l[i]);
		if(!t)continue;
		int tot = t + l[i] - 1;
		if(b[tot] + lazy[i] < x && b[tot] + lazy[i] > res) res = b[tot] + lazy[i];
	}
	for (int i = ql; i <= r[bl]; i ++) if (a[i] + lazy[bl] < x && a[i] + lazy[bl] > res) res = a[i] + lazy[bl];
	for (int i = l[br]; i <= qr; i ++) if (a[i] + lazy[br] < x && a[i] + lazy[br] > res) res = a[i] + lazy[br];
	return res;
}
int main() {
	read(n);
	for (int i = 1; i <= n; i ++) read(a[i]);
	init();
	for (int i = 1; i <= n; i ++) {
		int opt, l, r, x;
		read(opt), read(l), read(r), read(x);
		if (opt == 0) update(l, r, x);
		else {
			write(query(l, r, x));
			putchar('\n');
		}
	}
	return 0;
}

4.数列分块入门 4

思路

1.如何得出答案：

$(1)$对于完整的块⁵，每个块需要有$sum$ 数组要维护这个块的所有元素的和。

$(2)$对于不完整块⁶，因为元素比较少(最多有$n$ / 块数 = $\sqrt{n}$个) 即使是极限数据：$n=100000$的时候也最多有$317$个而外面是$\mathcal{O}(n)$, 所以是不会超的。综上，我们可以直接暴力扫这个小块统计答案，

2.如何区间修改：

这里，我们换种思路，**记录一个$lazy$**标记(由线段树启发得到),表示整个块被加上过多少了，

$(1)$对于完整块，因为每个元素都被加上了$x$, 我们直接$lazy+=x$,块内的和$ans+=x\ast block$(元素个数);

$(2)$对于不完整块，直接暴力修改就好了，顺便可以把$lazy$标记清$0$。

代码

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e4 + 5;
#define bl belong[ql]
#define br belong[qr]
typedef long long ll;
int n, block, len, belong[MAXN], l[MAXN], r[MAXN];
ll lazy[MAXN], sum[MAXN], a[MAXN];
template<typename T>
void read(T &x){
	x = 0;
	T f = 1;
	char ch = getchar();
	while(ch > '9' || ch < '0'){
		if(ch == '-')f = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9'){
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	x *= f;
}
template<typename T>
void write(T x){
	if(x < 0){
		putchar('-');
		x = -x;
	}
	if(x >= 10)write(x / 10);
	putchar(x % 10 + 48);
}
void init(){
	block = sqrt(n);
	len = n / block + (n % block != 0);
	for(int i = 1; i <= len; i ++){
		l[i] = (i - 1) * block + 1, r[i] = min(i * block, n);
		for(int j = l[i]; j <= r[i]; j ++)belong[j] = i, sum[i] += a[j];
	}
}
void update(int ql, int qr, int x){
	if(bl == br){
		for(int i = ql; i <= qr; i ++)a[i] += x, sum[bl] += x;
		return ;
	}
	for(int i = bl + 1; i < br; i ++)lazy[i] += x;
	for(int i = ql; i <= r[bl]; i ++)a[i] += x, sum[bl] += x;
	for(int i = l[br]; i <= qr; i ++)a[i] += x, sum[br] += x;
}
ll query(int ql, int qr, int mod){
	ll res = 0;
	if(bl == br){
		for(int i = ql; i <= qr; i ++)res = (res + a[i] + lazy[bl] + mod) % mod;
		return res;
	}
	for(int i = bl + 1; i < br; i ++)res = (res + sum[i] + lazy[i] * block + mod) % mod;
	for(int i = ql; i <= r[bl]; i ++)res = (res + a[i] + lazy[bl] + mod) % mod;
	for(int i = l[br]; i <= qr; i ++)res = (res + a[i] + lazy[br] + mod) % mod;
	return res;
}
int main(){
	read(n);
	for(int i = 1; i <= n; i ++)read(a[i]);
	init();
	for(int i = 1; i <= n; i ++){
		int opt, l, r, x;
		read(opt), read(l), read(r), read(x);
		if(opt == 0)update(l, r, x);
		else {
			write(query(l, r, x + 1));
			putchar('\n');
		}
	}
	return 0;
}

5.数列分块入门 5

思路

1.如何得出答案：

$(1)$对于完整的块⁵，每个块需要有$sum$ 数组要维护这个块的所有元素的和。

$(2)$对于不完整块⁶，因为元素比较少(最多有$n$ / 块数 = $\sqrt{n}$个) 即使是极限数据：$n=100000$的时候也最多有$317$个而外面是$\mathcal{O}(n)$, 所以是不会超的。综上，我们可以直接暴力扫这个小块统计答案，

2.如何区间修改：

这里，我们换种思路，**记录一个$lazy$**标记(由线段树启发得到),表示整个块被加上过多少了，

$(1)$对于完整块，直接暴力更新, 把$lazy$标记重新更新

$(2)$对于不完整块，还是直接暴力修改就好了，顺便可以把$lazy$标记重新更新。

代码

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e4 + 5;
#define bl belong[ql]
#define br belong[qr]
typedef long long ll;
int n, block, len, belong[MAXN], l[MAXN], r[MAXN];
ll lazy[MAXN], sum[MAXN], a[MAXN];
template<typename T>
void read(T &x) {
	x = 0;
	T f = 1;
	char ch = getchar();
	while (ch > '9' || ch < '0') {
		if (ch == '-')f = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	x *= f;
}
template<typename T>
void write(T x) {
	if (x < 0) {
		putchar('-');
		x = -x;
	}
	if (x >= 10)write(x / 10);
	putchar(x % 10 + 48);
}
void lazydown(int x) {
	sum[x] = lazy[x] = 0;
	for (int i = l[x]; i <= r[x]; i ++) sum[x] += a[i];
	for (int i = l[x]; i <= r[x]; i ++)
		if (a[i] > 1) {
			lazy[x] = 1;
			return ;
		}
}
void init() {
	block = sqrt(n);
	len = n / block + (n % block != 0);
	for (int i = 1; i <= len; i ++) {
		l[i] = (i - 1) * block + 1, r[i] = min(i * block, n);
		for (int j = l[i]; j <= r[i]; j ++) {
			belong[j] = i, sum[i] += a[j];
			if (a[j] > 1) lazy[i] = 1;
		}
	}
}
void update(int ql, int qr) {
	if (bl == br) {
		if (!lazy[bl]) return ;
		for (int i = ql; i <= qr; i ++) a[i] = sqrt(a[i]);
		lazydown(bl);
		return ;
	}
	for (int i = bl + 1; i < br; i ++) {
		if (!lazy[i]) continue;
		for (int j = l[i]; j <= r[i]; j ++) a[j] = sqrt(a[j]);
		lazydown(i);
	}
	for (int i = ql; i <= r[bl]; i ++) a[i] = sqrt(a[i]);
	lazydown(bl);
	for (int i = l[br]; i <= qr; i ++) a[i] = sqrt(a[i]);
	lazydown(br);
}
ll query(int ql, int qr) {
	ll res = 0;
	if (bl == br) {
		for (int i = ql; i <= qr; i ++) res += a[i];
		return res;
	}
	for (int i = bl + 1; i < br; i ++) res += sum[i];
	for (int i = ql; i <= r[bl]; i ++) res += a[i];
	for (int i = l[br]; i <= qr; i ++) res += a[i];
	return res;
}
int main() {
	read(n);
	for (int i = 1; i <= n; i ++)read(a[i]);
	init();
	for (int i = 1; i <= n; i ++) {
		int opt, l, r, x;
		read(opt), read(l), read(r), read(x);
		if (opt == 0)update(l, r);
		else {
			write(query(l, r));
			putchar('\n');
		}
	}
	return 0;
}

6.数列分块入门 6

思路

1.如何得出答案：

$(1)$对于完整的块⁵，每个块需要有$sum$ 数组要维护这个块的所有元素的和。

$(2)$对于不完整块⁶，因为元素比较少(最多有$n$ / 块数 = $\sqrt{n}$个) 即使是极限数据：$n=100000$的时候也最多有$317$个而外面是$\mathcal{O}(n)$, 所以是不会超的。综上，我们可以直接暴力扫这个小块统计答案，

2.如何区间修改：

这里，我们换种思路，**记录一个$lazy$**标记(由线段树启发得到),表示整个块被加上过多少了，

$(1)$对于完整块，因为每个元素都被加上了$x$, 我们直接$lazy+=x$,块内的和$ans+=x\ast block$(元素个数);

$(2)$对于不完整块，直接暴力修改就好了，顺便可以把$lazy$标记清$0$。

3.如何求$x$的前驱：

$(1)$要求一个数的前驱，显然我们要求块内元素是有序的，这样就能用$lower\_bound$⁷对块内查询.

$(2)$不完整的块暴力就好, 这样的话需要提前对每块里面的元素做一遍排序就好, 但是当有修改的话，因为整个块同时加上(减去)一个数，每个数的相对大小是不会变的，但是如果是不完全块就会改变，这样的话，还是因为元素个数小，重新新排一下不就得了?

代码

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
#define bl belong[ql]
#define br belong[qr]
#define pi pair<int, int>
#define fi first
#define se second
int n, block, len, a[MAXN << 1], m;
vector<int> b[MAXN];
template<typename T>
void read(T &x) {
	x = 0;
	T f = 1;
	char ch = getchar();
	while (ch > '9' || ch < '0') {
		if (ch == '-') f = -1;
		ch = getchar();
	}
	while (ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + (ch ^ 48);
		ch = getchar();
	}
	x *= f;
}
template<typename T>
void write(T x) {
	if (x < 0) {
		putchar('-');
		x = -x;
	}
	if (x >= 10)write(x / 10);
	putchar(x % 10 + 48);
}
void init() {
	block = sqrt(n);
	len = n / block + (n % block != 0);
	for (int i = 1; i <= len; i ++) {
		int l = (i - 1) * block + 1, r = min(block * i, n);
		for (int j = l; j <= r; j ++) b[i].push_back(a[j]);
	}
}
void build() {
	n = 0;
	for (int i = 1; i <= len; i ++) {
		int l = b[i].size();
		for (int j = 0; j < l; j ++) {
			a[++ n] = b[i][j];
		}
		b[i].clear();
	}
	init();
}
pi query(int x){
	int cnt = 1;
	while (b[cnt].size() < x) x -= b[cnt ++].size();
	return make_pair(cnt, x - 1);
}
void update(int pos, int x) {
	pi p = query(pos);
	int tot = p.fi, cnt = p.se;
	b[tot].insert(b[tot].begin() + cnt, x);
	if (b[tot].size() > block * 20) build();
}
int main() {
	read(n), m = n;
	for (int i = 1; i <= n; i ++) read(a[i]);
	init();
	for (int i = 1; i <= m; i ++) {
		int opt, l, r, x;
		read(opt), read(l), read(r), read(x);
		if (opt == 0) {
			update(l, r);
		}
		else {
			pi t = query(r);
			write(b[t.fi][t.se]);
			putchar('\n');
		}
	}
	return 0;
}

7.

思路

1.如何得出答案：

$(1)$对于完整的块⁵，每个块需要有$sum$ 数组要维护这个块的所有元素的和。

$(2)$对于不完整块⁶，因为元素比较少(最多有$n$ / 块数 = $\sqrt{n}$个) 即使是极限数据：$n=100000$的时候也最多有$317$个而外面是$\mathcal{O}(n)$, 所以是不会超的。综上，我们可以直接暴力扫这个小块统计答案，

2.如何区间修改：

这里，我们换种思路，**记录一个$lazy$**标记(由线段树启发得到),表示整个块被加上过多少了，

$(1)$对于完整块，因为每个元素都被加上了$x$, 我们直接$lazy+=x$,块内的和$ans+=x\ast block$(元素个数);

$(2)$对于不完整块，直接暴力修改就好了，顺便可以把$lazy$标记清$0$。

3.如何求$x$的前驱：

$(1)$要求一个数的前驱，显然我们要求块内元素是有序的，这样就能用$lower\_bound$⁷对块内查询.

$(2)$不完整的块暴力就好, 这样的话需要提前对每块里面的元素做一遍排序就好, 但是当有修改的话，因为整个块同时加上(减去)一个数，每个数的相对大小是不会变的，但是如果是不完全块就会改变，这样的话，还是因为元素个数小，重新新排一下不就得了?

8.

思路

1.如何得出答案：

$(1)$对于完整的块⁵，每个块需要有$sun$数组要维护这个块的所有元素的和。

$(2)$对于不完整块⁶，因为元素比较少(最多有$n$ / 块数 = $\sqrt{n}$个) 即使是极限数据：$n=100000$的时候也最多有$317$个而外面是$\mathcal{O}(n)$, 所以是不会超的。综上，我们可以直接暴力扫这个小块统计答案，

2.如何区间修改：

这里，我们换种思路，**记录一个$lazy$**标记(由线段树启发得到),表示整个块被加上过多少了，

$(1)$对于完整块，因为每个元素都被加上了$x$, 我们直接$lazy+=x$,块内的和$ans+=x\ast block$(元素个数);

$(2)$对于不完整块，直接暴力修改就好了，顺便可以把$lazy$标记清$0$。

3.如何求$x$的前驱：

$(1)$要求一个数的前驱，显然我们要求块内元素是有序的，这样就能用$lower\_bound$⁷对块内查询.

$(2)$不完整的块暴力就好, 这样的话需要提前对每块里面的元素做一遍排序就好, 但是当有修改的话，因为整个块同时加上(减去)一个数，每个数的相对大小是不会变的，但是如果是不完全块就会改变，这样的话，还是因为元素个数小，重新新排一下不就得了?

---

1. 其实这里的时间复杂度并不准确,只是大多数的代码近似于这个时间复杂度 ↩︎

2. 在洛谷(一个$OI$网站中)题目的难度分为灰, 红, 橙, 黄, 绿, 蓝, 紫, 黑, 灰。难度依次递增,而灰题是未判定难度的题。 ↩︎

3. 一种树形结构，可以维护区间求和和单点修改的优秀数据结构 ↩︎

4. 一种更加优秀的数据结构,可以完成大量的操作 ↩︎

5. 完整块：被操作区间完全覆盖的块 ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

6. 不完整块：操作区间不完全覆盖的块 ↩︎ ↩︎ ↩︎ ↩︎ ↩︎ ↩︎

7. 一种能在有序列表内，用$\mathcal{O}(\log n)$时间复杂度找到第一个大于等于所查询值的___地址___,也是$C$++的自带函数 ↩︎ ↩︎ ↩︎ ↩︎ ↩︎