LibreOJ 6277. 数列分块入门 1 题解

题目描述

给出一个长为 $n$ 的数列，以及 $n$ 个操作，操作涉及区间加法，单点查值。

输入格式

第一行输入一个数字 $n$。

第二行输入 $n$ 个数字，第 $i$ 个数字为 $a_i$，以空格隔开。

接下来输入 $n$ 行询问，每行输入四个数字 $opt$、$l$、$r$、$c$，以空格隔开。

若 $opt=0$，表示将位于 $[l,r]$ 之间的数字都加 $c$。

若 $opt=1$，表示询问 $a_r$ 的值（ $l$和 $c$ 忽略）。

输出格式

对于每次询问，输出一行一个数字表示答案。

样例输入

样例输出

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})$。

参考链接：https://www.cnblogs.com/louhancheng/p/10051136.html