一、定义:
线段树:维护区间操作的数据结构(区间查询,区间修改)(存放区间数据的二叉树)
条件:问题需满足区间加法,即对于[L, R]区间的答案,我们可以通过[L, Mid], [Mid+1, R]两个区间的答案合并求得。
整颗树的大致结构:
注:线段树本质上还是一颗线段树,但树状数组就只是单纯的一个数组了
二、操作:
1.区间修改
如果修改区间覆盖当前节点,那就修改该节点,并加上Lazy标记,其儿子不修改。
如果无法覆盖,那就看当前是否有Lazy标记,把Lazy标记先下传,然后再看修改区间与左右儿子的交集情况,如果有交集,那就递归修改。然后儿子修改结束后,用儿子新的值,去修改当前节点的值。
代码:
void update(int l, int r, int c, int s, int t, int p) {
// [l, r] 为修改区间, c 为被修改的元素的变化量, [s, t] 为当前节点包含的区间, p
// 为当前节点的编号
if (l <= s && t <= r) {
d[p] += (t - s + 1) * c, b[p] += c;
return;
} // 当前区间为修改区间的子集时直接修改当前节点的值,然后打标记,结束修改
int m = s + ((t - s) >> 1);
if (b[p] && s != t) {
// 如果当前节点的懒标记非空,则更新当前节点两个子节点的值和懒标记值
d[p * 2] += b[p] * (m - s + 1), d[p * 2 + 1] += b[p] * (t - m);
b[p * 2] += b[p], b[p * 2 + 1] += b[p]; // 将标记下传给子节点
b[p] = 0; // 清空当前节点的标记
}
if (l <= m) update(l, r, c, s, m, p * 2);
if (r > m) update(l, r, c, m + 1, t, p * 2 + 1);
d[p] = d[p * 2] + d[p * 2 + 1];
}
2.区间查询
判断查询区间是否覆盖当前节点,如果覆盖就直接返回当前节点值,否则先看是否有Lazy标记,先把Lazy下传,然后看查询区间,与左右儿子是否有交集,如果有交集,那就把递归儿子查询。
代码:
int getsum(int l, int r, int s, int t, int p) {
// [l, r] 为查询区间, [s, t] 为当前节点包含的区间, p 为当前节点的编号
if (l <= s && t <= r) return d[p];
// 当前区间为询问区间的子集时直接返回当前区间的和
int m = s + ((t - s) >> 1);
if (b[p]) {
// 如果当前节点的懒标记非空,则更新当前节点两个子节点的值和懒标记值
d[p * 2] += b[p] * (m - s + 1), d[p * 2 + 1] += b[p] * (t - m);
b[p * 2] += b[p], b[p * 2 + 1] += b[p]; // 将标记下传给子节点
b[p] = 0; // 清空当前节点的标记
}
int sum = 0;
if (l <= m) sum = getsum(l, r, s, m, p * 2);
if (r > m) sum += getsum(l, r, m + 1, t, p * 2 + 1);
return sum;
}
3.Lazy标记
如果需要查询当前带Lazy标记的区间,且不完全覆盖,那就需要将Lazy下传一层,再看与左右儿子的交集情况。
4.区间赋值
整体思路不变,依旧需要lazy节点,但额外需要一个v数组储存当前节点是否修改过值。
如果赋值区间覆盖当前节点,那就修改当前节点的值[ c * 区间长度 ],并设置Lazy节点。
如果无法覆盖,则看这个节点的v是否为true,如果为true,那就用当前节点的值给其子节点赋值,Lazy标记下传一层,并把该节点的v置为false,儿子的v置为true。
代码:
void update(int l, int r, int c, int s, int t, int p) {
if (l <= s && t <= r) {
d[p] = (t - s + 1) * c, b[p] = c;
return;
}
int m = s + ((t - s) >> 1);
// 额外数组储存是否修改值
if (v[p]) {
d[p * 2] = b[p] * (m - s + 1), d[p * 2 + 1] = b[p] * (t - m);
b[p * 2] = b[p * 2 + 1] = b[p];
v[p * 2] = v[p * 2 + 1] = 1;
v[p] = 0;
}
if (l <= m) update(l, r, c, s, m, p * 2);
if (r > m) update(l, r, c, m + 1, t, p * 2 + 1);
d[p] = d[p * 2] + d[p * 2 + 1];
}
int getsum(int l, int r, int s, int t, int p) {
if (l <= s && t <= r) return d[p];
int m = s + ((t - s) >> 1);
if (v[p]) {
d[p * 2] = b[p] * (m - s + 1), d[p * 2 + 1] = b[p] * (t - m);
b[p * 2] = b[p * 2 + 1] = b[p];
v[p * 2] = v[p * 2 + 1] = 1;
v[p] = 0;
}
int sum = 0;
if (l <= m) sum = getsum(l, r, s, m, p * 2);
if (r > m) sum += getsum(l, r, m + 1, t, p * 2 + 1);
return sum;
}
三、动态开点线段树
一般来说 线段树空间需要开到4n的长度,但有的时候会mle,所以我们可以优化一下。
为了节省空间,我们可以不一次性建好树,而是在最初只建立一个根结点代表整个区间。当我们需要访问某个子区间时,才建立代表这个区间的子结点。
这样我们不再使用 和
代表
结点的儿子,而是用 ls 和 rs 记录儿子的编号。总之,动态开点线段树的核心思想就是:结点只有在有需要的时候才被创建。
单次操作的时间复杂度是不变的,为 logn 。由于每次操作都有可能创建并访问全新的一系列结点,因此 次单点操作后结点的数量规模是 mlogn 。最多也只需要 2n-1 个结点,没有浪费。
代码:
单点修改:
// root 表示整棵线段树的根结点;cnt 表示当前结点个数
int n, cnt, root;
int sum[n * 2], ls[n * 2], rs[n * 2];
// 用法:update(root, 1, n, x, f); 其中 x 为待修改节点的编号
void update(int& p, int s, int t, int x, int f) { // 引用传参
if (!p) p = ++cnt; // 当结点为空时,创建一个新的结点
if (s == t) {
sum[p] += f;
return;
}
int m = s + ((t - s) >> 1);
if (x <= m)
update(ls[p], s, m, x, f);
else
update(rs[p], m + 1, t, x, f);
sum[p] = sum[ls[p]] + sum[rs[p]]; // pushup
}
区间查询:
// 用法:query(root, 1, n, l, r);
int query(int p, int s, int t, int l, int r) {
if (!p) return 0; // 如果结点为空,返回 0
if (s >= l && t <= r) return sum[p];
int m = s + ((t - s) >> 1), ans = 0;
if (l <= m) ans += query(ls[p], s, m, l, r);
if (r > m) ans += query(rs[p], m + 1, t, l, r);
return ans;
}
区间修改也是一样的,不过下放标记时要注意如果缺少孩子,就直接创建一个新的孩子。或者使用标记永久化技巧。