线段树的区间(加、乘)修改、区间询问

学习是一个持续的过程，每一小步都是进步。

———— 我也不知道是谁说的

1. 分析问题：修改、询问

痛点：直接暴力修改区间每个元素，时间复杂度会退化为 O(n) ，效率极低。
优化：懒标记（lazy tag） ，当修改区间完全覆盖线段树中某个节点区间时，不立即更新所有子节点，而是记录修改操作（打标记），等后续查询/修改需要访问子节点时，再下传标记，保证时间复杂度仍为 O(logn) 。
结构扩展：在节点结构体中加 add 字段，记录待下传的区间修改值（如区间每个元素加 add ）。
核心操作：
pushdown()：下传懒标记，更新子节点的统计值和子节点的懒标记。
update_range：区间修改主逻辑，覆盖时打标记，否则分裂区间，下传标记后递归修改。
例如，在 [1,10] 的线段树中修改 [4,8] 区间的每个值增加 20,找到完全覆盖的节点（如 [4,5]、[6,8] 等），打标记记录 +20，不立即更新子节点；后续查询/修改涉及这些子节点时，通过 pushdown() 下传标记，更新子节点值和标记。

2. 区间修改的关键：lazy-tag

lazy： 修改一个整块区间时，只对这个线段区间进行整体上的修改，其内部每个元素的内容先不做修改。只有当这部分线段的一致性被破坏时，才把变化值传递给子区间。
tag： 对做 lazy 操作的子区间，记录状态

3. 区间加法

下传懒标记：将当前节点的 add 标记传递给左右子节点

void pushdown(int p) {if (tr[p].add) { // 有懒标记需要下传// 更新左孩子tr[lc].sum += tr[p].add * (tr[lc].r   - tr[lc].l + 1);tr[lc].add += tr[p].add;// 更新右孩子tr[rc].sum += tr[p].add * (tr[rc].r - tr[rc].l + 1);tr[rc].add += tr[p].add;// 清除当前节点的懒标记tr[p].add = 0;}
}

区间更新：给区间 [x,y] 每个数加 k

void update_interval(int p, int x, int y, ll k) {// 完全覆盖，直接更新sum和懒标记if (x <= tr[p].l && tr[p].r <= y) {tr[p].sum += k * (tr[p].r - tr[p].l + 1);tr[p].add += k;return ;}pushdown(p); // 递归子节点前先下传懒标记int m = (tr[p].l + tr[p].r) >> 1;if (x <= m) update_interval(lc, x, y, k); // 左子树有重叠if (y > m) update_interval(rc, x, y, k); // 右子树有重叠tr[p].sum = tr[lc].sum + tr[rc].sum; // 回溯更新当前节点sum
}

完整代码

#include <bits/stdc++.h>
using namespace std;#define N 100010
#define ll long long#define lc p << 1 // 左孩子编号：p*2
#define rc p << 1|1 // 右孩子编号：p*2+1int n, m;
ll w[N]; // 原数组，用ll防止溢出struct tree {ll l, r, sum, add; // add用于懒标记（区间更新专属优化）
};
tree tr[N * 4];// 下传懒标记：将当前节点的add标记传递给左右子节点
void pushdown(int p) {if (tr[p].add) { // 有懒标记需要下传// 更新左孩子tr[lc].sum += tr[p].add * (tr[lc].r - tr[lc].l + 1);tr[lc].add += tr[p].add;// 更新右孩子tr[rc].sum += tr[p].add * (tr[rc].r - tr[rc].l + 1);tr[rc].add += tr[p].add;// 清除当前节点的懒标记tr[p].add = 0;}
}void build(int p, int l, int r) { // p:根节点tr[p] = {l, r, w[l], 0}; // add先置0if(l == r) return ;int m = (l + r) >> 1;build(lc, l, m); // 左子树build(rc, m + 1, r); // 右子树tr[p].sum = tr[lc].sum + tr[rc].sum; // 当前节点sum=左右子树sum之和
}// 区间更新：给区间[x,y]每个数加k
void update_interval(int p, int x, int y, ll k) {// 完全覆盖，直接更新sum和懒标记if (x <= tr[p].l && tr[p].r <= y) {tr[p].sum += k * (tr[p].r - tr[p].l + 1);tr[p].add += k;return ;}pushdown(p); // 递归子节点前先下传懒标记int m = (tr[p].l + tr[p].r) >> 1;if (x <= m) update_interval(lc, x, y, k); // 左子树有重叠if (y > m) update_interval(rc, x, y, k); // 右子树有重叠tr[p].sum = tr[lc].sum + tr[rc].sum; // 回溯更新当前节点sum
}// 单点更新：给第pos个位置的数加k（修复：添加pushdown调用）
void update_single(int p, int pos, ll k) {// 找到目标叶子节点if (tr[p].l == tr[p].r) {tr[p].sum += k; // 更新叶子节点的sum（单点的和就是自身值）return;}pushdown(p);int m = (tr[p].l + tr[p].r) >> 1;// 判断目标位置在左子树还是右子树，递归更新对应子树if (pos <= m) update_single(lc, pos, k); // 左子树包含目标位置else update_single(rc, pos, k); // 右子树包含目标位置tr[p].sum = tr[lc].sum + tr[rc].sum; // 回溯更新当前节点sum
}// 区间查询（查询区间[x,y]的和）
ll query(int p, int x, int y) {if (x <= tr[p].l && tr[p].r <= y) { // 完全覆盖，直接返回return tr[p].sum;}pushdown(p); // 递归子节点前先下传懒标记int m = (tr[p].l + tr[p].r) >> 1;ll sum = 0;if (x <= m) sum += query(lc, x, y); // 左子树有重叠if (y > m) sum += query(rc, x, y); // 右子树有重叠return sum;
}int main(){ios::sync_with_stdio(false);cin.tie(0);cin >> n >> m;for(int i = 1; i <= n; ++i){cin >> w[i];}build(1, 1, n); // 构建线段树，根节点为1，覆盖[1,n]for(int i = 1; i <= m; ++i){int zwy;cin >> zwy;if(zwy == 1){int x, y;ll k;cin >> x >> y >> k;update_interval(1, x, y, k); // 区间更新（指令1）}else if(zwy == 2){int pos; ll k;cin >> pos >> k;update_single(1, pos, k); // 单点更新（指令2）}else{int x, y;cin >> x >> y;cout << query(1, x, y) << '\n'; // 区间查询（指令3）}}return 0;
}

4. 区间加、乘法

下传懒标记：将当前节点的 mul 和 add 标记传递给左右子节点

void pushdown(int p) {// 无孩子if (tr[p].l == tr[p].r) return;// 乘法懒标记if (tr[p].mul != 1) {// 更新左孩子tr[lc].sum *= tr[p].mul;tr[lc].mul *= tr[p].mul; // 乘法标记下传tr[lc].add *= tr[p].mul; // 加法标记乘以mul// 更新右孩子tr[rc].sum *= tr[p].mul;tr[rc].mul *= tr[p].mul;tr[rc].add *= tr[p].mul;// 清除乘法懒标记tr[p].mul = 1;}// 加法懒标记if (tr[p].add != 0) {// 更新左孩子tr[lc].sum += tr[p].add * (tr[lc].r - tr[lc].l + 1);tr[lc].add += tr[p].add; // 加法标记下传// 更新右孩子tr[rc].sum += tr[p].add * (tr[rc].r - tr[rc].l + 1);tr[rc].add += tr[p].add;// 清除加法懒标记tr[p].add = 0;}
}

区间更新：给区间 [x,y] 每个数加或乘 k

// 区间乘法
void update_cheng(int p, int x, int y, ll k) {// 完全覆盖当前区间，直接更新并记录懒标记if (x <= tr[p].l && tr[p].r <= y) {tr[p].sum *= k;tr[p].mul *= k; // 乘法懒标记tr[p].add *= k; // 加法标记乘以kreturn;}pushdown(p); // 下传懒标记int m = (tr[p].l + tr[p].r) >> 1;if (x <= m) update_cheng(lc, x, y, k); // 更新左子树if (y > m) update_cheng(rc, x, y, k); // 更新右子树tr[p].sum = tr[lc].sum + tr[rc].sum; // 回溯更新当前节点
}// 区间加法
void update_jia(int p, int x, int y, ll k) {// 完全覆盖，直接更新if (x <= tr[p].l && tr[p].r <= y) {tr[p].sum += k * (tr[p].r - tr[p].l + 1);tr[p].add += k;return ;}pushdown(p);int m = (tr[p].l + tr[p].r) >> 1;if (x <= m) update_jia(lc, x, y, k);if (y > m) update_jia(rc, x, y, k);tr[p].sum = tr[lc].sum + tr[rc].sum; // 回溯更新sum
}

完整代码

#include <bits/stdc++.h>
using namespace std;#define N 100010
#define ll long long#define lc p << 1 // 左孩子编号：p*2
#define rc p << 1|1 // 右孩子编号：p*2+1int n, m;
ll w[N]; // 原数组，用ll防止溢出struct tree {ll l, r, sum; // 区间左边界、右边界、区间和ll add, mul;  // 加法懒标记、乘法懒标记（补充mul，修复问题3）
};
tree tr[N * 4];// 懒标记下传
void pushdown(int p) {// 无孩子if (tr[p].l == tr[p].r) return;// 乘法懒标记if (tr[p].mul != 1) {// 更新左孩子tr[lc].sum *= tr[p].mul;tr[lc].mul *= tr[p].mul; // 乘法标记下传tr[lc].add *= tr[p].mul; // 加法标记乘以mul// 更新右孩子tr[rc].sum *= tr[p].mul;tr[rc].mul *= tr[p].mul;tr[rc].add *= tr[p].mul;// 清除乘法懒标记tr[p].mul = 1;}// 加法懒标记if (tr[p].add != 0) {// 更新左孩子tr[lc].sum += tr[p].add * (tr[lc].r - tr[lc].l + 1);tr[lc].add += tr[p].add; // 加法标记下传// 更新右孩子tr[rc].sum += tr[p].add * (tr[rc].r - tr[rc].l + 1);tr[rc].add += tr[p].add;// 清除加法懒标记tr[p].add = 0;}
}// 构建线段树
void build(int p, int l, int r) {tr[p] = {l, r, 0, 0, 1};if (l == r) {tr[p].sum = w[l];return;}int m = (l + r) >> 1;build(lc, l, m); // 构建左子树build(rc, m + 1, r); // 构建右子树tr[p].sum = tr[lc].sum + tr[rc].sum;
}// 区间乘法
void update_cheng(int p, int x, int y, ll k) {// 完全覆盖当前区间，直接更新并记录懒标记if (x <= tr[p].l && tr[p].r <= y) {tr[p].sum *= k;tr[p].mul *= k; // 乘法懒标记tr[p].add *= k; // 加法标记乘以kreturn;}pushdown(p); // 下传懒标记int m = (tr[p].l + tr[p].r) >> 1;if (x <= m) update_cheng(lc, x, y, k); // 更新左子树if (y > m) update_cheng(rc, x, y, k); // 更新右子树tr[p].sum = tr[lc].sum + tr[rc].sum; // 回溯更新当前节点
}// 区间加法
void update_jia(int p, int x, int y, ll k) {// 完全覆盖，直接更新if (x <= tr[p].l && tr[p].r <= y) {tr[p].sum += k * (tr[p].r - tr[p].l + 1);tr[p].add += k;return ;}pushdown(p);int m = (tr[p].l + tr[p].r) >> 1;if (x <= m) update_jia(lc, x, y, k);if (y > m) update_jia(rc, x, y, k);tr[p].sum = tr[lc].sum + tr[rc].sum; // 回溯更新sum
}// 区间查询
ll query(int p, int x, int y) {if (x <= tr[p].l && tr[p].r <= y) { // 完全覆盖，直接返回当前区间sumreturn tr[p].sum;}pushdown(p);int m = (tr[p].l + tr[p].r) >> 1;ll sum = 0;if (x <= m) sum += query(lc, x, y);if (y > m) sum += query(rc, x, y);return sum;
}int main(){ios::sync_with_stdio(false);cin.tie(0);cin >> n >> m;for(int i = 1; i <= n; ++i){cin >> w[i];}build(1, 1, n);for(int i = 1; i <= m; ++i){int zwy;cin >> zwy;if(zwy == 1){int x, y;ll k;cin >> x >> y >> k;update_cheng(1, x, y, k);}else if(zwy == 2){int x, y;ll k;cin >> x >> y >> k;update_jia(1, x, y, k);}else{int x, y;cin >> x >> y;cout << query(1, x, y) << '\n'; }}return 0;
}

5. 知识点小结

线段树的核心优化是懒标记 (lazy tag)，核心思想是延迟更新，将区间修改的时间复杂度从 O(n) 优化为 O(logn)。
懒标记的核心操作是pushdown()，只有在需要访问子节点时才下传标记，保证每次操作的效率。
单加法懒标记只需维护add，初始化值为 0；加 + 乘复合懒标记需要维护 add 和 mul，初始化mul=1、add=0，且下传顺序必须先乘后加。
线段树数组的空间必须开原数组的 4 倍，防止越界。
所有区间修改、区间查询操作的递归逻辑一致：完全覆盖则直接处理，否则分裂区间递归处理，最后回溯更新当前节点信息。
线段树的核心适用场景：高频的区间修改 + 高频的区间查询类问题。