【数据结构】线段树

例题1：

给定一个正整数数列 $a_1,a_2,\dots ,a_n$，每一个数都在 $0\sim p-1$ 之间。 可以对这列数进行两种操作：

1. 添加操作：向序列后添加一个数，序列长度变成 $n+1$；
2. 询问操作：询问这个序列中最后 $L$ 个数中最大的数是多少。

程序运行的最开始，整数序列为空。 一共要对整数序列进行 $m$ 次操作。 写一个程序，读入操作的序列，并输出询问操作的答案。
数据范围

$1\le m\le 2\times 10^5$
$1\le p\le 2\times 10^9$
$0\le t<p$

这道题看第一眼：暴力，再看一眼：爆炸（bushi TLE。
这道题目就可以用我们今天要学的线段树来解决。

线段树的思路

线段树是一棵二叉树，它可以在很低的时间复杂度内完成一个序列的单点修改、区间修改、区间查询（最大数，最小数、求和等等）等的操作， $[1,n]$ 线段树支持的所有操作都可以将时间复杂度控制在$O(logn)$。
线段树俗称段错误树，因调试时经常段错误而得名
它的的思路很好理解， 顾名思义，它就是一个节点为线段的树；假设我们要用线段树维护一个区间 $[1,10]$ ：

如何存储线段树

我们直接拿一个结构体来存储线段树，每一个节点都是一段区间，拿刚才的例题举例：

struct Node {
    int l, r;	//	区间的左端点和右端点
    int v;  //  区间[l, r]中的最大值
    //	这里可以存储你要维护的任何信息，例如最大/最小值，区间和等
} tr[N * 4];

一棵线段树的根节点编号为 $1$ ，设一个不为根节点的节点编号为 $u$ ，则这个节点的父节点是 $\lfloor \frac{u}{2}\rfloor$ ，它的左儿子编号为 $2\times u$ ，右儿子编号为 $2\times u+1$ ；因为一颗线段树最大是一棵满二叉树，N个叶子节点的满二叉树最多有 $N+N÷2+N÷4+...+2+1=2N-1$ 个节点；而最后一层（可以参考上面的 $[1,10]$ 线段树图）最多还会剩余 $2N$ 个节点。所以线段树通常需要开 $4N$ 倍的空间。

如何建立线段树

线段树中如果表示的区间为 $[l,r]$ 且这个节点不为叶子节点（$l\ne r$），则我们有一个 $mid=\lfloor \frac{l+r}{2}\rfloor$ , 这个点的左子树即为 $[l,mid]$ ，右子树即为 $[mid+1,r]$ ，递归建树即可。
代码：

void pushup(int u) {    //  由子节点的最大值，来更新父节点的信息
    tr[u].v = max(tr[u * 2].v, tr[u * 2 + 1].v);
}
void build(int u, int l, int r) {
    tr[u] = {l, r};
    if (l == r) return ;
    int mid = l + r >> 1;
    build(u * 2, l, mid), build(u * 2 + 1, mid + 1, r);
}

如何进行查询

递归查询，直到我们树中结点已经完全包含在我们需要查询的区间中
代码：

int query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].v;   //  树中节点已经被完全包含在[l, r]中了
    int mid = tr[u].l + tr[u].r >> 1;
    int v = 0;
    if (l <= mid) v = query(u * 2, l, r);
    if (r > mid) v = max(v, query(u * 2 + 1, l, r));
    return v;
}

如何进行修改

递归寻找，直到我们找到了我们将要修改的叶子节点（只有一个数的区间），进行修改。

void modify(int u, int x, int v) {
    if (tr[u].l == x && tr[u].r == x) tr[u].v = v;
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u * 2, x, v);
        else modify(u * 2 + 1, x, v);
        pushup(u);	//	别忘了告诉父节点我们刚刚进行更新的信息
    }
}

例题1完整代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200010;
int m, p;
struct Node {
    int l, r;
    int v;
} tr[N * 4];
void pushup(int u) {
    tr[u].v = max(tr[u * 2].v, tr[u * 2 + 1].v);
}
void build(int u, int l, int r) {
    tr[u] = {l, r};
    if (l == r) return ;
    int mid = l + r >> 1;
    build(u * 2, l, mid), build(u * 2 + 1, mid + 1, r);
}
int query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].v;
    int mid = tr[u].l + tr[u].r >> 1;
    int v = 0;
    if (l <= mid) v = query(u * 2, l, r);
    if (r > mid) v = max(v, query(u * 2 + 1, l, r));
    return v;
}
void modify(int u, int x, int v) {
    if (tr[u].l == x && tr[u].r == x) tr[u].v = v;
    else {
        int mid = tr[u].l + tr[u].r >> 1;
        if (x <= mid) modify(u * 2, x, v);
        else modify(u * 2 + 1, x, v);
        pushup(u);
    }
}
int main() {
    int n = 0, last = 0;
    scanf("%d%d", &m, &p);
    build(1, 1, m);
    char op[2];
    int x;
    while ( m -- ) {
        scanf("%s%d", op, &x);
        if (*op == 'Q') {
            last = query(1, n - x + 1, n);
            printf("%d\n", last);
        } else {
            modify(1, n + 1, ((ll)last + x) % p);
            n ++ ;
        }
    }
    return 0;
}

进阶线段树（线段树的懒标记）

例题2：

给定一个长度为 $N$ 的数列 $A$，以及 $M$ 条指令，每条指令可能是以下两种之一：

1. C l r d，表示把 $A[l],A[l+1],\dots ,A[r]$ 都加上 $d$。
2. Q l r，表示询问数列中第 $l\sim r$ 个数的和。

对于每个询问，输出一个整数表示答案。
数据范围

$1\le N,M\le 10^5$
$|d|\le 10000$
$|A[i]|\le 10^9$

这道题我之前讲过分块的做法，具体可以查看我的另一篇博客：C++分块详解
我在这篇博客里吐槽了段错误树懒标记，那我们就学一学懒标记是什么
我们之前写的代码里有一个pushup函数，意思是由子节点的信息更新父节点的信息；我们还是拿上面的线段树举例：假设我要维护线段树每个区间的和，把区间的 $[6,8]$ 中的数字 $6$ 变成 $7$ ，则这段区间的和由 $6+7+8=21$ 变成了 $7+7+8=22$，同时它的所有父节点即 $[6,10]$， $[1,10]$ 的和全都需要更新。时间复杂度为$O(n)$；但是我们之前说过，线段树支持的所有操作都可以将时间复杂度控制在$O(logn)$，那我们该怎么优化它呢？
没错，这就需要我们现在要学的懒标记操作，也称延迟标记。意思就是说，我们可以在线段树的结构体内加上一个标记add，在执行修改命令时，直接将add赋值为我们想要增加的数，表示“这个节点被我修改过，但我还未更新下面的子节点的信息”；后续查询时，我们只需要检查这个节点的父节点有没有背过“懒标记”的锅，如果有，就将这个节点和它父节点的另外一个子节点也标记上懒标记，再清除父节点的懒标记即可。

例题2完整代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 100010;
int n, m;
int w[N];
struct Node {
    int l, r;
    ll sum, add;    //  sum是区间的和，add是区间的懒标记
} tr[N * 4];
void pushup(int u) {
    tr[u].sum = tr[u * 2].sum + tr[u * 2 + 1].sum;
}
void pushdown(int u) {  //  向下传递懒标记
    auto &root = tr[u], &left = tr[u * 2], &right = tr[u * 2 + 1];
    if (root.add) {
        left.add += root.add, left.sum += (ll)(left.r - left.l + 1) * root.add;
        right.add += root.add, right.sum += (ll)(right.r - right.l + 1) * root.add;
        root.add = 0;
    }
}
void build(int u, int l, int r) {
    if (l == r) tr[u] = {l, r, w[r], 0};
    else {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u * 2, l, mid), build(u * 2 + 1, mid + 1, r);
        pushup(u);
    }
}
void modify(int u, int l, int r, int d) {
    if (tr[u].l >= l && tr[u].r <= r) {
        tr[u].sum += (ll)(tr[u].r - tr[u].l + 1) * d;
        tr[u].add += d;
    } else {    //  别忘了分开
        pushdown(u);
        int mid = tr[u].l + tr[u].r >> 1;
        if (l <= mid) modify(u * 2, l, r, d);
        if (r > mid) modify(u * 2 + 1, l, r, d);
        pushup(u);
    }
}
ll query(int u, int l, int r) {
    if (tr[u].l >= l && tr[u].r <= r) return tr[u].sum;
    pushdown(u);
    int mid = tr[u].l + tr[u].r >> 1;
    ll sum = 0;
    if (l <= mid) sum = query(u * 2, l, r);
    if (r > mid) sum += query(u * 2 + 1, l, r);
    return sum;
}
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i ++ ) scanf("%d", &w[i]);
    build(1, 1, n);
    char op[2];
    int l, r, d;
    while (m -- ) {
        scanf("%s%d%d", op, &l, &r);
        if (*op == 'C') {
            scanf("%d", &d);
            modify(1, l, r, d);
        } else {
            printf("%lld\n", query(1, l, r));
        }
    }
    return 0;
}

好啦，那我们的线段树到这里就讲完啦，可以给我一个赞吗uwu