线段树详解

线段树

这是一棵线段树，线段树是一颗严格的二叉树，根节点存储了区间长度为 $n=8$ 的信息，每个节点会不断二分为 $2$ 个子节点，分别包含原本一半的信息，节点会二分到区间大小变成 $1$ 为止，同时该线段树高度为 $\lceil lo{g}_{2}n\rceil +1$。

同时若每个节点的编号为 $d$，则其子节点的编号为 $d\ast 2$ 和 $d\ast 2+1$。

线段树的建立

从根节点开始建立线段树，不断递归构建其左右孩子，直至叶子节点（区间大小为 $1$）。回溯时，每个节点从左右孩子节点统计信息，完成区间信息合并。（这一操作我们会用 $pushup()$ 函数实现）

线段树的查询

对于这样一个数据结构，当我们需要查询一个区间的信息，只要从根节点出发，不断向子节点递归，直到**当前节点的区间完全被包含于查询的区间，就可以向上汇总信息。**例如：

查询区间 $[1]$

查询区间 $[3,4]$

查询区间 $[4,7]$

可以说，除了查询区间的两边可能出现在线段树的叶子节点，查询区间的中间部分都可以在非叶子节点查询到，且区间越大，中间部分被查找到的深度越低，所以线段树的查询操作的复杂度为 $O(lo{g}_{2}n)$ 级。

线段树的修改

线段树的修改分为单点修改和区间修改。

只需要单点修改的线段树修改时都会到达叶子节点，更改叶子节点的信息，在回溯的时候更新路径上各节点的区间信息。复杂度 $O(lo{g}_{2}n)$。如：

需要区间修改的线段树，保证所有查询的正确性，则每次需要更新到区间的所有叶子节点，那复杂度将达到 $O(n)$，这个复杂度写暴力不香🐎。所以我们需要加入一点点优化：延迟标记 $(lazy-tag)$。

延迟标记是什么呢 跟它的名字一样，是用来偷懒的。

当我们递归到节点区间完全被修改区间包含，我们可以对这个节点进行修改，同时给这个节点打上标记，表示这个节点被修改过，但其的子节点尚未修改。等到查询到这个节点时再修改（标记下传 : $pushdown()$ 函数）。

code

// 以区间加法为例
#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define maxn 100000
#define dl (d << 1)      // => d * 2
#define dr (d << 1 | 1)  // => d * 2 + 1

struct node {
    ll l, r, sum, tag;
    node() : l(0), r(0), sum(0), tag(0) {}
} sgt[(maxn << 2) + 5];

ll n, m, a[maxn + 5];
// pushup 从左右孩子合并信息
void pushup(ll d) { sgt[d].sum = sgt[dl].sum + sgt[dr].sum; }
// pushdown 更新子节点信息 & 标记下传
void pushdown(ll d) {
    sgt[dl].sum += (sgt[dl].r - sgt[dl].l + 1) * sgt[d].tag;
    sgt[dr].sum += (sgt[dr].r - sgt[dr].l + 1) * sgt[d].tag;
    sgt[dl].tag += sgt[d].tag;
    sgt[dr].tag += sgt[d].tag;
    sgt[d].tag = 0;
}
// 修改
void add(ll d, ll l, ll r, ll k) {
    // 遇到处于修改区间内的节点 修改 打上标记 并返回
    if (sgt[d].l >= l && sgt[d].r <= r) {
        sgt[d].sum += k * (sgt[d].r - sgt[d].l + 1);
        sgt[d].tag += k;
        return;
    }
    int mid = sgt[d].l + sgt[d].r >> 1;
    if (sgt[d].tag) pushdown(d);  // 有tag先更新子节点 & 标记下传
    if (l <= mid) add(dl, l, r, k);  // 查询左端点<=mid => 左孩子需要修改
    if (r > mid) add(dr, l, r, k);  // 查询右端点>mid => 右孩子需要修改
    pushup(d);                      // 回溯时从子节点更新
}
// 建树
void build(ll d, ll l, ll r) {
    sgt[d].l = l;  // 节点左右端点赋值
    sgt[d].r = r;
    sgt[d].tag = 0;
    if (l == r) {  // 到达叶子节点 赋初值 返回
        sgt[d].sum = a[l];
        return;
    }
    ll mid = l + r >> 1;
    build(dl, l, mid);
    build(dr, mid + 1, r);
    pushup(d);  // 回溯时从子节点统计信息
}
// 查询
ll query(ll d, ll l, ll r) {
    if (sgt[d].l >= l && sgt[d].r <= r)
        return sgt[d].sum;        // 在查询区间内返回和
    if (sgt[d].tag) pushdown(d);  // 有tag先更新子节点 & 标记下传
    ll ret = 0;
    int mid = sgt[d].l + sgt[d].r >> 1;
    if (l <= mid) ret += query(dl, l, r);
    if (r > mid) ret += query(dr, l, r);
    return ret;
}

int main() {
    scanf("%lld%lld", &n, &m);
    for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
    build(1, 1, n);
    while (m--) {
        ll op, l, r;
        scanf("%lld%lld%lld", &op, &l, &r);
        if (op == 1) {  // op为1时 [l,r]加k
            ll k;
            scanf("%lld", &k);
            add(1, l, r, k);
        } else {  // op为2时 查询[l,r]的和
            printf("%lld\n", query(1, l, r));
        }
    }
    return 0;
}