LibreOJ 6277. 数列分块入门 1 题解
题目链接：https://loj.ac/problem/6277
题目描述
给出一个长为 \(n\) 的数列，以及 \(n\) 个操作，操作涉及区间加法，单点查值。
输入格式
第一行输入一个数字 \(n\)。
第二行输入 \(n\) 个数字，第 \(i\) 个数字为 \(a_i\)，以空格隔开。
接下来输入 \(n\) 行询问，每行输入四个数字 \(opt\)、\(l\)、\(r\)、\(c\)，以空格隔开。
若 \(opt=0\)，表示将位于 \([l,r]\) 之间的数字都加 \(c\)。
若 \(opt=1\)，表示询问 \(a_r\) 的值（ \(l\)和 \(c\) 忽略）。
输出格式
对于每次询问，输出一行一个数字表示答案。
样例输入
4
1 2 2 3
0 1 3 1
1 0 1 0
0 1 2 2
1 0 2 0
样例输出
2
5
数据范围与提示
对于 \(100%\) 的数据，\(1 \le n \le 50000, -2^{31} \le others,ans \le 2^{31}-1\)。
解题思路
本题涉及的算法：数列分块 。
数列分块，就是把一个长度为 \(n\) 的数组，拆分成一个个连续的长度为 \(\lfloor \sqrt{n} \rfloor\) 的小块（如果 \(n\) 不能被 \(\lfloor \sqrt{n} \rfloor\) 整除，则最后一个分块的长度为 \(n\) mod \(\lfloor \sqrt{n} \rfloor\)）。
然后我们这里设 \(m = \sqrt{n}\)，那么我们可以定义数组中的第 \(i\) 个元素 \(a_i\) 所属的分块为 \(\lfloor \frac{i-1}{m} \rfloor + 1\)（即：\(a_1,a_2, \cdots ,a_m\) 属于第 \(1\) 个分块，\(a_{m+1},a_{m+2}, \cdots ,a_{2m}\) 属于第 \(2\) 个分块，……）。
为了入门方便起见，我们定义一个数组 \(p[i]\) 表示 \(a_i\) 所属的分组编号。
scanf("%d", &n);
m = sqrt(n);
for (int i = 1; i <= n; i ++) p[i] = (i-1)/m + 1;
for (int i = 1; i <= n; i ++) scanf("%d", &a[i]);
实际上，所有的分块都是这样：把一个数列分成几块，然后对它们进行批量处理。
一般来说，我们直接把块大小设为 \(\sqrt{n}\)，但实际上，有时候我们要根据数据范围、具体复杂度来确定块大小。
更新操作
我们来分析一下这里的更新操作。
因为我们本题只涉及一种类型的更新操作——给区间 \([l,r]\) 范围内的每一个数增加一个值 \(c\)。
这些数必定是属于连续的块 \(p[l], p[l]+1, \cdots , p[r]\) 内的。
并且我们可以发现：当块的数量 \(\gt 2\) 时，除了 \(p[l]\) 和 \(p[r]\) 这两块可能存在“部分元素需要更新”的情况，其余所有的分块（\(p[l]+1, p[l]+2, \cdots , p[r]-1\)）都是将整块元素都增加了 \(c\) 的。
对于编号为 \(k\) 的分块，我们可以知道属于这个分块的元素的编号从 \(m \times (k-1)+1\) 到 \(m \times k\)。
如果我们的更新操作面临着将一整块的元素都更新 \(c\)（即每个元素都增加\(c\)），那么我们可以采取如下朴素方法：
for (int i = m*(k-1)+1; i <= m*k; i ++)
a[i] += c;
这种方法的时间复杂度是 \(O(m) = O( \sqrt{n} )\)。
但其实我们不需要对一整块当中的每一个元素都加 \(c\) ，因为他们都加上 \(c\) 了，所以我干脆标记这个分块有个整体的增量 \(c\) 即可。
我们可以开一个大小为 \(\sqrt{n}\) 的数组 \(v\)，其中 \(v[i]\) 用于表示第 \(i\) 个分块的整体更新量。
那么，当我需要对编号为 \(k\) 的那个块进行整体的更新操作，我可以执行如下代码：
v[k] += c;
所以，我们可以将区间 \([l,r]\) 整体增加 \(c\) 的操作拆分如下：
首先，如果 \(a[l]\) 和 \(a[r]\) 属于同一个分块（那么只有一个不完整的分块），我还是朴素地从 \(a[l]\) 到 \(a[r]\) 遍历并将每个元素加上 \(c\)：
if (p[l] == p[r]) { // 说明在同一个分块，直接更新
for (int i = l; i <= r; i ++) a[i] += c;
return;
}
否则，说明从 \(a[l]\) 到 \(a[r]\) 至少有两个分块。
我们把问题拆分成三步走：
- 更新最左边的那个分块；
- 更新最右边的那个分块；
- 更新中间的那些分块（如果有的话）。
step.1 更新最左边的那个分块
首先我们来分析最左边的分块，即 \(a[l]\) 所属的分块：
- 如果 \(l\) mod \(m \ne 1\)，说明 \(a[l]\) 不是他所在的分块的第一个元素，那么我还是需要从 \(a[l]\) 开始从前往后更新所有和 \(a[l]\) 属于同一个分块的元素（即：将所有满足条件 \(i \ge l\) 且 \(p[i] = p[l]\) 的 \(a[i]\) 加上 \(c\)）；
- 否则（即 \(l\) mod \(m = 1\)），说明 \(a[l]\) 是他所在的分块的第一个元素，那么我们只要整块更新即可：\(v[p[l]] += c\)。
if (l % m != 1) { // 说明l不是分块p[l]的第一个元素
for (int i = l; p[i]==p[l]; i ++)
a[i] += c;
}
else v[p[l]] += c;
step.2 更新最右边的那个分块
接下来我们来分析最右边的分块，即 \(a[r]\) 所属的分块：
- 如果 \(r\) mod \(m = 0\)，说明 \(a[r]\) 不是他所在的分块的最后一个元素，那么我们需要从 \(a[r]\) 开始从后往前更新所有和 \(a[r]\) 属于同一个分块的元素（即：将所有满足条件 \(i \le r\) 且 \(p[i] = p[r]\) 的 \(a[i]\) 加上 \(c\)）；
- 否则（即 \(r\) mod \(m = 0\)），说明 \(a[r]\) 是他所在的分块的最后一个元素，那么我们只需要整块更新即可：\(v[p[r]] += c\)。
if (r % m != 0) { // 说明r不是分块p[r]的最后一个元素
for (int i = r; p[i]==p[r]; i --)
a[i] += c;
}
else v[p[r]] += c;
3. 更新中间的那些分块（如果有的话）
在前两步当中，我们已经更新完了最左边的分块（\(a[l]\)所属的分块）及最右边的分块（\(a[r]\)所属的分块），那么剩下来的就是中间的那些分块（即编号为\(p[l]+1, p[l]+2, \cdots , p[r]-1\)的那些分块），这些分块都是整块更新的，所有对于这些分块，我们直接将更新量 \(c\) 加到其整体更新量当中即可。
for (int i = p[l]+1; i < p[r]; i ++)
v[i] += c;
查询操作
如果我们现在要查询 \(a[i]\) 对应的值，那么他应该对应两部分：
- \(a[i]\) 本身的值；
- \(a[i]\) 所属的分块 \(p[i]\) 的整体更新量 \(v[p[i]]\)。
所以 \(a[i]\) 的实际值为 \(a[i] + v[p[i]]\)。
这样，我们就分析玩了数列分块对应的更新和查询这两种操作。
完整实现代码如下：
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50050;
int n, m, a[maxn], p[maxn], v[300], op, l, r, c;
void add(int l, int r, int c) {
if (p[l] == p[r]) { // 说明在同一个分块，直接更新
for (int i = l; i <= r; i ++) a[i] += c;
return;
}
if (l % m != 1) { // 说明l不是分块p[l]的第一个元素
for (int i = l; p[i]==p[l]; i ++)
a[i] += c;
}
else v[p[l]] += c;
if (r % m != 0) { // 说明r不是分块p[r]的最后一个元素
for (int i = r; p[i]==p[r]; i --)
a[i] += c;
}
else v[p[r]] += c;
for (int i = p[l]+1; i < p[r]; i ++)
v[i] += c;
}
int main() {
scanf("%d", &n);
m = sqrt(n);
for (int i = 1; i <= n; i ++) p[i] = (i-1)/m + 1;
for (int i = 1; i <= n; i ++) scanf("%d", a+i);
for (int i = 0; i < n; i ++) {
scanf("%d%d%d%d", &op, &l, &r, &c);
if (op == 0) add(l, r, c);
else printf("%d\n", a[r] + v[p[r]]);
}
return 0;
}
时间复杂度分析
更新
更新最左边的那个分块：
因为每个分块的元素不超过 \(\sqrt{n}\) 所以操作次数不会超过 \(\sqrt{n}\)；
更新最右边的那个分块：
因为每个分块的元素不超过 \(\sqrt{n}\) 所以操作次数不会超过 \(\sqrt{n}\)；
更新中间的那些分块：
因为分块个数不会超过 \(\sqrt{n}+1\) 所以中间那些分块的数量不会超过 \(\sqrt{n}\)。
所以更新一次的时间复杂度为 \(O( \sqrt{n} ) + O( \sqrt{n} ) + O( \sqrt{n} ) = O( \sqrt{n} )\)。
查询
查询直接返回 \(a[i] + v[p[i]]\) ，所以查询的时间复杂度为 \(O(1)\)。
综上所述，因为一共有 \(n\) 次操作，所以该算法的时间复杂度为 \(O(n \sqrt{n})\)。
