|
|
## $zkw$ 线段树
|
|
|
|
|
|
[参考博文I](https://codeforces.com/blog/entry/18051) 这篇英文文献还是要看一下的，有意思~
|
|
|
[参考博文II](https://blog.csdn.net/yanweiqi1754989931/article/details/117575178)
|
|
|
|
|
|
俗称 **重口味** ，与 $KMP$ 类似，咳咳...
|
|
|
只要没标记，我都写 $zkw$ 线段树。。 只要有标记，我都写递归版线段树。。
|
|
|
|
|
|
|
|
|
### 一、$ZKW$线段树简介
|
|
|
$ZKW$线段树是由清华大学姚班大佬 **张昆玮** 所创立的一种线段树储存结构，由于其基于非递归的实现方式以及精简的代码和较高的效率而闻名。甚至，$ZKW$线段树能够可持久化。
|
|
|
|
|
|
我们从算法的角度对基础线段树进行分析：其实线段树算法本身的本质仍是统计。因此我们可以从统计的角度入手对线段树进行分析：线段树是将一个个数轴划分为区间进行处理的，因此我们面对的往往是一系列的离散量，这导致了我们在使用时的线段树单纯的退化为一棵"点树"(即最底层的线段树只包含一个点)。基于这一点可以入手对线段树进行优化。
|
|
|
|
|
|
### 二、$ZKW$线段树的构造原理
|
|
|
|
|
|
首先，我们忽略线段树中的数据，从线段树的框架结构入手进行分析：如图所示是一颗采用堆式储存的基本线段树：
|
|
|
|
|
|
<center><img src='https://img-blog.csdnimg.cn/20210604234646100.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbndlaXFpMTc1NDk4OTkzMQ==,size_16,color_FFFFFF,t_70#pic_center'></center>
|
|
|
|
|
|
我们将节点编号转换为二进制：
|
|
|
|
|
|
<center><img src='https://img-blog.csdnimg.cn/20210604234653819.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbndlaXFpMTc1NDk4OTkzMQ==,size_16,color_FFFFFF,t_70#pic_center'></center>
|
|
|
|
|
|
观察转为二进制后的结点规律：在基础线段树的学习中，我们知道对于任意结点$x$，其左子节点为$x<<1$，右子节点为$x<<1 ∣ 1$。这个规律是我们从根结点出发向叶节点寻找的规律。那么现在我们换个思路：从叶结点出发向根结点寻找规律：
|
|
|
|
|
|
* 当前结点的父节点一定是当前的结点右移一位(舍弃低位)得到的
|
|
|
* 当前结点的左子节点为$x<<1$，右子节点为$x<<1 ∣ 1$
|
|
|
* 每一层结点按照顺序排列，第$n$层有$2^{n-1}$个节点
|
|
|
* 最后一层的结点个数 = 值域
|
|
|
|
|
|
因为最后一层的结点个数=值域，假设给定数组$a[n]$，含有元素$a[1] \sim a[n]$。
|
|
|
|
|
|
我们约定，无论元素的个数是否达到$2^n$，最后一层的空间都开到$2^n$，无数据的叶节点空置即可。
|
|
|
|
|
|
### 三、$ZKW$线段树基本操作
|
|
|
|
|
|
#### 1.建树操作
|
|
|
```cpp {.line-numbers}
|
|
|
void build(int n){
|
|
|
for(m = 1; m <= n;) m <<= 1;
|
|
|
for (int i = m + 1; i <= m + n; ++i) op_array[i] = read();
|
|
|
for (int i = m - 1; i; --i) operation(),
|
|
|
}
|
|
|
```
|
|
|
|
|
|
- 如果维护区间和，那么$op\_array[] \rightarrow sum[]，operation$
|
|
|
```cpp {.line-numbers}
|
|
|
sum[i] = sum[i << 1] + sum[i << 1 | 1];
|
|
|
```
|
|
|
|
|
|
- 如果维护区间最小值，那么$op\_array[] \rightarrow minn[]，operation$
|
|
|
```cpp {.line-numbers}
|
|
|
minn[i] = min(minn[i << 1], minn[i << 1 | 1])； //不支持修改操作
|
|
|
```
|
|
|
|
|
|
```cpp {.line-numbers}
|
|
|
minn[i] = min(minn[i << 1], minn[i << 1 | 1]),
|
|
|
minn[i << 1] -= minn[i], minn[i << 1 | 1] -= minn[i];
|
|
|
```
|
|
|
|
|
|
- 如果维护区间最大值，那么$op\_array[] \rightarrow maxx[]，operation$
|
|
|
```cpp {.line-numbers}
|
|
|
maxx[i] = max(maxx[i << 1], maxx[i << 1 | 1]); //不支持修改操作
|
|
|
```
|
|
|
|
|
|
```cpp {.line-numbers}
|
|
|
maxx[i] = max(maxx[i << 1], maxx[i << 1 | 1]),
|
|
|
maxx[i << 1] -= maxx[i], maxx[i << 1 | 1] -= maxx[i];
|
|
|
```
|
|
|
|
|
|
#### 2.单点查询
|
|
|
这个操作是相对容易理解的，就是一个从叶子结点开始，不断向父节点走，同时累加沿路的权值的过程。
|
|
|
|
|
|
```cpp {.line-numbers}
|
|
|
int query(int x){
|
|
|
int ans = 0;
|
|
|
for (x += m; x; x >>= 1) ans += minn[s];
|
|
|
return ans;
|
|
|
}
|
|
|
```
|
|
|
|
|
|
|
|
|
#### 3.单点修改
|
|
|
单点修改的思路非常简单，只需要修改当前结点并更新父节点即可。
|
|
|
```cpp {.line-numbers}
|
|
|
void update(int x,int v){
|
|
|
op_array[x = m + x] += v;
|
|
|
while(x) operation();
|
|
|
}
|
|
|
```
|
|
|
- 如果维护区间和，那么$op\_array[] \rightarrow sum[]，operation:$
|
|
|
```cpp {.line-numbers}
|
|
|
sum[i] = a[i << 1] + a[i << 1 | 1];
|
|
|
```
|
|
|
|
|
|
```cpp {.line-numbers}
|
|
|
//如果单纯维护区间和，那么可以压行：
|
|
|
void update(int p, int k){ for (p += m; p; p >>= 1) sum[p] += k; }
|
|
|
```
|
|
|
|
|
|
- 如果维护区间最小值，那么$op\_array[] \rightarrow minn[]，operation$
|
|
|
```cpp {.line-numbers}
|
|
|
minn[i] = min(minn[i << 1], minn[i << 1 | 1]),
|
|
|
minn[i << 1] -= minn[i], minn[i << 1 | 1] -= minn[i];
|
|
|
```
|
|
|
|
|
|
- 如果维护区间最大值，那么$op\_array[] \rightarrow maxx[]，operation$
|
|
|
```cpp {.line-numbers}
|
|
|
maxx[i] = max(maxx[i << 1], maxx[i << 1 | 1]),
|
|
|
maxx[i << 1] -= maxx[i], maxx[i << 1 | 1] -= maxx[i];
|
|
|
```
|
|
|
|
|
|
#### 4.区间查询
|
|
|
如何进行区间查询？我们继续二进制表示入手，寻找查询的规律。
|
|
|
|
|
|
在实际的查询中，我们采取扩增左右区间端点的方式进行查询，即：将闭区间转换为开区间查询。
|
|
|
|
|
|
我们以下图为例：假设要查询的区间为$[1,2]$，那么首先转换为开区间$(0,3)$，我们可以发现变为开区间之后，$0$的兄弟结点必在区间之内，$3$的兄弟结点必在区间内；根据这个规律我们可以总结：
|
|
|
|
|
|
对于待查区间$[l,r]$：
|
|
|
|
|
|
- 如果$l$是左儿子，则其兄弟结点必位于区间之内；
|
|
|
- 如果$r$是右儿子，则其兄弟结点必位于区间之内；
|
|
|
- 查询的终止条件：两个结点同为兄弟；
|
|
|
- 以上结论，对于任意层的结点均成立。
|
|
|
|
|
|
我们通过例子来模拟这个过程：
|
|
|
|
|
|
<center><img src='https://img-blog.csdnimg.cn/20210604234719972.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbndlaXFpMTc1NDk4OTkzMQ==,size_16,color_FFFFFF,t_70#pic_center'></center>
|
|
|
|
|
|
在如图所示的$ZKW$线段树中，假设我们要查询区间$[1,4]$，那么步骤如下：
|
|
|
|
|
|
- 闭区间改开区间，$[1,4]$改为查询$(0,5)$，扩增至$(M + 0, M + 5) = (8, 13)$；
|
|
|
- 判断：左端点$D[1000_B]$是左儿子，那么其兄弟$D[1001_B]$必位于区间内，累加$ans + = D[1001_B]$
|
|
|
判断：右端点$D[1101_B]$是右儿子，那么其兄弟$D[1100_B]$必位于区间内，累加$ans + = D[ 1100_B]$
|
|
|
- 缩小区间(向根结点缩)：$l > > = 1 → 1000 >> 1 = 0100 ， r > > = 1 → 1101 > > 1 = 0110 $
|
|
|
|
|
|
- 判断：左端点$D[0100_B]$是左儿子，那么其兄弟$D[0101_B]$必位于区间内，累加$an s + = D[0101_B]$
|
|
|
判断：右端点$D[0110_B]$是左儿子，不做操作；
|
|
|
|
|
|
- 缩小区间(向根结点缩)：$l >> = 1 → 0100 > > 1 = 0010 ， r > > = 1 → 0110 > > 1 = 0011$
|
|
|
|
|
|
- 此时$l$和$r$同为兄弟，因此终止查询。
|
|
|
|
|
|
我们可以总结出区间查询的步骤：
|
|
|
|
|
|
* 闭区间改开区间$[l, r] → ( l + M − 1 , r + M + 1 )$
|
|
|
* 判断当前区间左端点是否是左儿子，如果是，则向累加器中累加兄弟结点；
|
|
|
判断当前区间右端点是否为右儿子，如果是，则向累加器中累加兄弟结点；
|
|
|
* 端点变量处理操作：$l > > = 1 , r > > = 1$
|
|
|
* 循环执行$2 − 3$的步骤，直到$l$和$r$同为兄弟结点(此时不终止会导致重复计算)
|
|
|
|
|
|
如何判断是否为左子节点？我们很容易观察到左右子节点共同的特征：左子节点最低位为$0$ ，右子节点最低位为$1$，那么我们可以通过以下操作的真值判断左右子节点
|
|
|
|
|
|
- 判断左子节点：`∼l & 1`
|
|
|
`l % 2 == 0`的意思
|
|
|
- 判断右子节点：`r & 1`
|
|
|
` r % 2 == 1`的意思
|
|
|
|
|
|
对于取兄弟结点的值则可以通过与$1$异或求得：
|
|
|
|
|
|
- 左子节点求兄弟结点：`l xor 1`
|
|
|
- 右子节点求兄弟结点：`r xor 1`
|
|
|
|
|
|
|
|
|
**延绵的山峰 无修改维护最值**
|
|
|
```cpp {.line-numbers}
|
|
|
/*
|
|
|
延绵的山峰
|
|
|
★★☆ 输入文件：climb.in 输出文件：climb.out 简单对比
|
|
|
时间限制：1 s 内存限制：512 MB
|
|
|
问题描述
|
|
|
有一座延绵不断、跌宕起伏的山，最低处海拔为0，最高处海拔不超过8848米，从这座山的一端走到另一端的过程中，
|
|
|
每走1米海拔就升高或降低1米。有Q个登山队计划在这座山的不同区段登山，当他们攀到各自区段的最高峰时，就会插上队旗。
|
|
|
请你写一个程序找出他们插旗的高度。
|
|
|
|
|
|
输入文件
|
|
|
第1行，一个整数N(N<=10^6)，表示山两端的跨度。
|
|
|
接下来N+1行，每行一个非负整数Hi，表示该位置的海拔高度，其中H0=Hn=0。
|
|
|
|
|
|
然后是一个正整数Q(Q<=7000)，表示登山队的数量。
|
|
|
接下来Q行，每行两个数Ai, Bi，表示第i个登山队攀爬的区段[Ai,Bi]，其中0<=Ai<=Bi<=N。
|
|
|
|
|
|
输出文件
|
|
|
Q行，每行为一个整数，表示第i个登山队插旗的高度。
|
|
|
|
|
|
样例输入
|
|
|
10
|
|
|
0
|
|
|
1
|
|
|
2
|
|
|
3
|
|
|
2
|
|
|
3
|
|
|
4
|
|
|
3
|
|
|
2
|
|
|
1
|
|
|
0
|
|
|
5
|
|
|
0 10
|
|
|
2 4
|
|
|
3 7
|
|
|
7 9
|
|
|
8 8
|
|
|
|
|
|
样例输出
|
|
|
4
|
|
|
3
|
|
|
4
|
|
|
3
|
|
|
2
|
|
|
*/
|
|
|
#include <cstdio>
|
|
|
#include <algorithm>
|
|
|
#include <cstring>
|
|
|
using namespace std;
|
|
|
const int N = 100010;
|
|
|
// 快读
|
|
|
int read() {
|
|
|
int x = 0, f = 1;
|
|
|
char ch = getchar();
|
|
|
while (ch < '0' || ch > '9') {
|
|
|
if (ch == '-') f = -1;
|
|
|
ch = getchar();
|
|
|
}
|
|
|
while (ch >= '0' && ch <= '9') {
|
|
|
x = (x << 3) + (x << 1) + (ch ^ 48);
|
|
|
ch = getchar();
|
|
|
}
|
|
|
return x * f;
|
|
|
}
|
|
|
|
|
|
int d[N << 2], m;
|
|
|
|
|
|
//构建zkw线段树
|
|
|
void build(int n) {
|
|
|
for (m = 1; m < n;) m <<= 1; // 强行开够（大于n）方便二进制访问叶节点
|
|
|
for (int i = 1; i <= n; i++) d[m + i] = read(); //对zkw的叶子节点赋值
|
|
|
for (int i = m; i; i--) d[i] = max(d[i << 1], d[i << 1 | 1]); //待所有叶子节点有值后，统一执行一次向上数据统计信息汇总
|
|
|
}
|
|
|
|
|
|
//区间查询最大值
|
|
|
int query(int l, int r) {
|
|
|
int ans = 0;
|
|
|
for (l = l + m - 1, r = r + m + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
|
|
|
if (~l & 1) ans = max(d[l ^ 1], ans);
|
|
|
if (r & 1) ans = max(d[r ^ 1], ans);
|
|
|
}
|
|
|
return ans;
|
|
|
}
|
|
|
|
|
|
int main() {
|
|
|
//文件输入输出
|
|
|
#ifndef ONLINE_JUDGE
|
|
|
freopen("Cogs58.in", "r", stdin);
|
|
|
#endif
|
|
|
int n, q, l, r;
|
|
|
/*
|
|
|
第1行，一个整数N(N<=10^6)，表示山两端的跨度。
|
|
|
接下来N+1行，每行一个非负整数Hi，表示该位置的海拔高度，其中H0=Hn=0。
|
|
|
*/
|
|
|
n = read(), n++; // H0~Hn 共n+1行，而且，题目告诉我们H0=Hn=0,会在输入数据时给出,所以，一共是n+1点
|
|
|
|
|
|
//构建
|
|
|
build(n);
|
|
|
|
|
|
q = read();
|
|
|
for (int i = 1; i <= q; i++) {
|
|
|
l = read(), r = read();
|
|
|
printf("%d\n", query(l + 1, r + 1));
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
```
|
|
|
|
|
|
[$I$ $Hate$ $It$ $HDU$ - $1754$ 单点更新，区间查询](http://acm.hdu.edu.cn/showproblem.php?pid=1754)
|
|
|
```cpp {.line-numbers}
|
|
|
#include <algorithm>
|
|
|
#include <cstdio>
|
|
|
#include <cstring>
|
|
|
using namespace std;
|
|
|
|
|
|
const int N = 2e5 + 1000;
|
|
|
// 快读
|
|
|
int read() {
|
|
|
int x = 0, f = 1;
|
|
|
char ch = getchar();
|
|
|
while (ch < '0' || ch > '9') {
|
|
|
if (ch == '-') f = -1;
|
|
|
ch = getchar();
|
|
|
}
|
|
|
while (ch >= '0' && ch <= '9') {
|
|
|
x = (x << 3) + (x << 1) + (ch ^ 48);
|
|
|
ch = getchar();
|
|
|
}
|
|
|
return x * f;
|
|
|
}
|
|
|
// zkw线段树
|
|
|
int d[N << 2];
|
|
|
|
|
|
int n; // n个叶子节点
|
|
|
int q; // q个操作,区间查询或单点修改
|
|
|
int m; // m是指所有父节点们的个数
|
|
|
|
|
|
void pushup(int x) {
|
|
|
for (int i = (m + x) >> 1; i; i >>= 1) d[i] = max(d[i << 1], d[i << 1 | 1]);
|
|
|
}
|
|
|
|
|
|
//单点修改并psuhup
|
|
|
void modify(int x, int c) {
|
|
|
d[m + x] = c;
|
|
|
pushup(x);
|
|
|
}
|
|
|
|
|
|
//构建重口味树
|
|
|
void built() {
|
|
|
memset(d, 0, sizeof d);
|
|
|
for (m = 1; m <= n + 1;) m <<= 1; // 强行开够（大于n）方便二进制访问叶节点
|
|
|
for (int i = 1; i <= n; i++) d[m + i] = read(); //初始值
|
|
|
for (int i = m; i; i--) d[i] = max(d[i << 1], d[i << 1 | 1]); //待所有叶子节点有值后，统一执行一次向上数据统计信息汇总
|
|
|
}
|
|
|
|
|
|
//区间查询
|
|
|
int query(int l, int r) {
|
|
|
int ans = -1;
|
|
|
// 闭区间改为开区间：l=l+m-1 : 将查询区间改为l-1, r=r+m+1 : 将查询区间改为r+1
|
|
|
// l^r^1 : 相当于判断l与r是否是兄弟节点
|
|
|
for (l = l + m - 1, r = r + m + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
|
|
|
if (~l & 1) ans = max(ans, d[l ^ 1]); // l % 2 == 0 左端点 是左儿子 max(右子树)，想像一下题解中0号端点（哨兵），肯定是%2=0
|
|
|
if (r & 1) ans = max(ans, d[r ^ 1]); // r % 2 == 1 右端点 是右儿子 max(左子树)，想像一下题解中1号端点，肯定是%2=1
|
|
|
}
|
|
|
return ans;
|
|
|
}
|
|
|
|
|
|
//方法重载，单点查询 [本题没有用到，用来做模板的]
|
|
|
int query(int x) {
|
|
|
return d[m + x]; //直接返回结果的zkw线段树节点值
|
|
|
}
|
|
|
|
|
|
int main() {
|
|
|
//文件输入输出
|
|
|
#ifndef ONLINE_JUDGE
|
|
|
freopen("HDU1754.in", "r", stdin);
|
|
|
#endif
|
|
|
char op[2];
|
|
|
while (~scanf("%d%d", &n, &q)) {
|
|
|
//构建zkw树
|
|
|
built();
|
|
|
|
|
|
while (q--) {
|
|
|
scanf("%s", op);
|
|
|
int l = read(), r = read();
|
|
|
if (op[0] == 'Q')
|
|
|
printf("%d\n", query(l, r));
|
|
|
else
|
|
|
modify(l, r);
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
```
|
|
|
|
|
|
[$HDU$ $1166$ 敌兵布阵 单点增加，区间查询](http://acm.hdu.edu.cn/showproblem.php?pid=1166)
|
|
|
```cpp {.line-numbers}
|
|
|
#include <cstdio>
|
|
|
#include <cstring>
|
|
|
#include <algorithm>
|
|
|
|
|
|
using namespace std;
|
|
|
|
|
|
//快读
|
|
|
int read() {
|
|
|
int x = 0, f = 1;
|
|
|
char ch = getchar();
|
|
|
while (ch < '0' || ch > '9') {
|
|
|
if (ch == '-') f = -1;
|
|
|
ch = getchar();
|
|
|
}
|
|
|
while (ch >= '0' && ch <= '9') {
|
|
|
x = (x << 3) + (x << 1) + (ch ^ 48);
|
|
|
ch = getchar();
|
|
|
}
|
|
|
return x * f;
|
|
|
}
|
|
|
|
|
|
const int N = 50000 + 10;
|
|
|
|
|
|
int m = 1, n;
|
|
|
int d[N << 2];
|
|
|
|
|
|
//区间查询
|
|
|
int query(int l, int r) {
|
|
|
int ans = 0;
|
|
|
for (l = l + m - 1, r = r + m + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
|
|
|
if (~l & 1) ans += d[l ^ 1];
|
|
|
if (r & 1) ans += d[r ^ 1];
|
|
|
}
|
|
|
return ans;
|
|
|
}
|
|
|
|
|
|
//向上更新统计信息
|
|
|
void pushup(int x) {
|
|
|
for (int i = (m + x) >> 1; i; i >>= 1) d[i] = d[i << 1] + d[i << 1 | 1];
|
|
|
}
|
|
|
|
|
|
//单点增加
|
|
|
void add(int x, int c) {
|
|
|
d[m + x] += c;
|
|
|
pushup(x);
|
|
|
}
|
|
|
|
|
|
void build(int n) {
|
|
|
memset(d, 0, sizeof d);
|
|
|
for (m = 1; m < n;) m <<= 1; // 强行开够（大于n）方便二进制访问叶节点
|
|
|
for (int i = 1; i <= n; i++) d[m + i] = read(); //初始值
|
|
|
for (int i = m; i; i--) d[i] = d[i << 1] + d[i << 1 | 1]; //待所有叶子节点有值后，统一执行一次向上数据统计信息汇总
|
|
|
}
|
|
|
|
|
|
int main() {
|
|
|
//文件输入输出
|
|
|
#ifndef ONLINE_JUDGE
|
|
|
freopen("HDU1166.in", "r", stdin);
|
|
|
#endif
|
|
|
int k = read();
|
|
|
|
|
|
for (int q = 1; q <= k; q++) {
|
|
|
n = read();
|
|
|
//构建zkw线段树
|
|
|
build(n);
|
|
|
|
|
|
printf("Case %d:\n", q);
|
|
|
|
|
|
char op[10];
|
|
|
while (scanf("%s", op)) {
|
|
|
if (op[0] == 'E') break;
|
|
|
int l = read(), r = read();
|
|
|
if (op[0] == 'Q')
|
|
|
printf("%d\n", query(l, r));
|
|
|
else if (op[0] == 'A')
|
|
|
add(l, r);
|
|
|
else if (op[0] == 'S')
|
|
|
add(l, -r);
|
|
|
}
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
```
|
|
|
|
|
|
#### 5.区间修改
|
|
|
|
|
|
[参考题解](https://www.cnblogs.com/Parsnip/p/10785894.html)
|
|
|
|
|
|
在普通的线段树中，一般用 $lazy$ $tag$ 来解决这个问题，$zkw$线段树同样可以，但从上向下操作、下放 $lazy$ $tag$ 等操作并不优雅,**常数大**。
|
|
|
|
|
|
可以采用 **标记永久化**，随用随查，按$zkw$的说法——永久化的标记就是值。
|
|
|
|
|
|
考虑上文提到的区间操作的过程，自下向上走的过程中，根据遇到的标记来计算贡献。
|
|
|
|
|
|
对于一个节点，若修改操作对节点所代表的整个区间产生影响，显然我们可以直接对该节点进行标记，而非逐层递归修改。
|
|
|
那么，在自底向上的线段树中，我们可以不下传标记，而是在每一次查询时，统计累加一路上所有标记对答案产生的影响，这种标记思想被称为**标记永久化**。
|
|
|
|
|
|
**区间修改**
|
|
|
关于标记永久化，我们进行定义：$add[i]$代表线段树中$i$号节点的关键值已经进行修改，但是其所有子节点均有一个值为$add[i]$的增量未进行处理。
|
|
|
|
|
|
设置两个开区间指针$l,r$，并同时向上遍历。同时，我们维护三个变量$lc,rc,c$，分别代表:
|
|
|
- 当前左端点走到的子树有多少个元素在修改区间内
|
|
|
- 当前右端点走到的子树有多少个元素在修改区间内
|
|
|
- 当前层叶子节点个数
|
|
|
|
|
|
利用上述变量和$add$标记的定义，沿路更新$add$标记和原线段树即可，当然，对于$l,r$成为兄弟后，我们还须将$add$标记一直上推到根节点。
|
|
|
|
|
|
**区间求和**
|
|
|
有了$add$标记，我们就很容易求得区间的和了: 将闭区间转换为开区间，然后向上遍历，
|
|
|
|
|
|
同样维护$lc,rc,c$，然后利用$add$标记进行累加，再加上原来的区间和，就能得到答案。
|
|
|
|
|
|
**[例题P3372 【模板】线段树 1](https://www.luogu.org/problemnew/show/P3372)**
|
|
|
```cpp {.line-numbers}
|
|
|
#include <cstdio>
|
|
|
#include <algorithm>
|
|
|
#include <cstring>
|
|
|
using namespace std;
|
|
|
#define LL long long
|
|
|
#define N 100010
|
|
|
|
|
|
//对于区间修改 区间求和的zkw线段树，最重要的思想就是标记永久化的思想
|
|
|
|
|
|
//快读
|
|
|
LL read() {
|
|
|
LL x = 0, f = 1;
|
|
|
char ch = getchar();
|
|
|
while (ch < '0' || ch > '9') {
|
|
|
if (ch == '-') f = -1;
|
|
|
ch = getchar();
|
|
|
}
|
|
|
while (ch >= '0' && ch <= '9') {
|
|
|
x = (x << 3) + (x << 1) + (ch ^ 48);
|
|
|
ch = getchar();
|
|
|
}
|
|
|
return x * f;
|
|
|
}
|
|
|
int n, q, m;
|
|
|
LL sum[N << 2], add[N << 2];
|
|
|
|
|
|
void build() {
|
|
|
for (m = 1; m <= n;) m <<= 1;
|
|
|
for (int i = 1; i <= n; i++) sum[m + i] = read();
|
|
|
for (int i = m - 1; i >= 1; i--) sum[i] = sum[i << 1] + sum[i << 1 | 1];
|
|
|
}
|
|
|
|
|
|
void modify(int l, int r, int d) {
|
|
|
int lc = 0, rc = 0, c = 1;
|
|
|
// 开区间，从左右叶子端点出发，如果l和r不是兄弟节点，就一路向上
|
|
|
// lc 表示当前左端点走到的子树有多少个元素在修改区间内
|
|
|
// rc 表示当前右端点走到的子树有多少个元素在修改区间内
|
|
|
// c 当前层叶子节点个数
|
|
|
for (l = m + l - 1, r = m + r + 1; l ^ r ^ 1; l >>= 1, r >>= 1, c <<= 1) {
|
|
|
sum[l] += d * lc, sum[r] += d * rc; //自底向上，更新统计信息sum和
|
|
|
if (~l & 1) add[l ^ 1] += d, sum[l ^ 1] += d * c, lc += c; // l % 2 == 0 左端点 是左儿子 右子树完整在区间内
|
|
|
if (r & 1) add[r ^ 1] += d, sum[r ^ 1] += d * c, rc += c; // r % 2 == 1 右端点 是右儿子 左子树完整在区间内
|
|
|
}
|
|
|
//是兄弟节点时，需要一路向上到根进行推送
|
|
|
for (; l || r; l >>= 1, r >>= 1) sum[l] += d * lc, sum[r] += d * rc;
|
|
|
}
|
|
|
|
|
|
//区间查询
|
|
|
LL query(int l, int r) {
|
|
|
LL lc = 0, rc = 0, c = 1;
|
|
|
LL res = 0;
|
|
|
for (l = m + l - 1, r = m + r + 1; l ^ r ^ 1; l >>= 1, r >>= 1, c <<= 1) {
|
|
|
if (add[l]) res += add[l] * lc;
|
|
|
if (add[r]) res += add[r] * rc;
|
|
|
if (~l & 1) res += sum[l ^ 1], lc += c;
|
|
|
if (r & 1) res += sum[r ^ 1], rc += c;
|
|
|
}
|
|
|
for (; l || r; l >>= 1, r >>= 1) res += add[l] * lc, res += add[r] * rc;
|
|
|
return res;
|
|
|
}
|
|
|
|
|
|
int main() {
|
|
|
//文件输入输出
|
|
|
#ifndef ONLINE_JUDGE
|
|
|
freopen("P3372.in", "r", stdin);
|
|
|
#endif
|
|
|
n = read(), q = read();
|
|
|
|
|
|
build();
|
|
|
for (int i = 1; i <= q; i++) {
|
|
|
int op = read();
|
|
|
int l = read(), r = read();
|
|
|
if (op == 1) {
|
|
|
int c = read();
|
|
|
modify(l, r, c);
|
|
|
} else
|
|
|
printf("%lld\n", query(l, r));
|
|
|
}
|
|
|
return 0;
|
|
|
}
|
|
|
```
|
|
|
|
|
|
### 五、总结
|
|
|
简单总结一下，上面也说过，这东西除了卡常就没什么用，还不见得有原版线段树好写
|
|
|
|
|
|
实战中一般不会有人特意放 $zkw$ 过然后卡递归线段树
|
|
|
|
|
|
感觉实用性甚至不如什么猫树
|
|
|
|
|
|
不过思想还可以，值得学学
|
|
|
|
|
|
|
|
|
运行情况对比: $P3372$ 【模板】线段树 1
|
|
|
|
|
|
|
|
|
版本1：zkw线段树+标记永久化 第10个测试点 44ms/3.75MB
|
|
|
版本2：zkw线段树+pushup+pushdown 第10个测试点 85ms/5.87MB
|
|
|
版本3：zkw线段树+cf_zkw变异版本，内存2*N 第10个测试点 60ms/2.71MB
|
|
|
版本4：树状数组+差分 第10个测试点 31ms/2.36MB
|
|
|
版本5：递归版本普通线段树 第10个测试点 105ms/8.33MB
|
|
|
|
|
|
总结：
|
|
|
(1) 普通线段树最牛B，没有之一，对，你没有看错，因为大家基本上是一个级别的，
|
|
|
比最快的仅仅慢3倍而已，我过不了，你估计也过不了，因为出题人一般都是卡一个复杂度的，卡常数不容易。
|
|
|
ZKW这个东东，没有必要再花时间研究了，因为快也快不到哪里去，还徒增学习的时间，不划算。
|
|
|
|
|
|
(2) 有哪些问题是线段树可以解决但树状数组解决不了的？
|
|
|
树状数组可以维护前缀和（或后缀和），维护不了一般的区间和，而线段树可以轻松维护。
|
|
|
这里的“和”是指一种满足结合律的运算的累算，例如普通加/乘法、最大/小值、矩阵乘法、
|
|
|
最大公约数等等。可以求差的运算也可以用树状数组维护前缀和来计算区间和，
|
|
|
比如普通加法的区间和是两个前缀和的差，
|
|
|
可以很容易支持 区间修改+单点询问 或 单点修改+区间询问，但没法很好地同时支持
|
|
|
区间修改+区间询问（有时也可以强行懒惰更新）。
|
|
|
|
|
|
不能求差的运算，树状数组就维护不了区间和了，比如区间最大/小值、区间最大公约数。
|
|
|
其实树状数组只是线段树的一个特殊形式，因为不需要询问前缀以外的子区间，需要维护的信息更少，
|
|
|
把线段树上的一些不需要的节点删去了。 |
