标记永久化

也就是没有 push_down

注意前面两个问题是具有启发性的，不要略去不看

区间加，单点和

每个节点 \(u\) 额外维护一个 add 值，表示 \(u\) 所代表的区间的总增加量

此时只考虑该区间的增加情况，不用考虑它祖先或者儿子的增加情况

这样做的代价是查询时把没考虑的祖先 以及 儿子 的增加情况考虑进去

区间加：把 \(\log n\) 个点的 add 加一下

单点和：对于一个单点，所有包含它的区间的 add 都对他有贡献

于是把经过的节点的 add 累加起来回答

区间加，区间和

对当前区间 \(u\)，可以想到维护两个信息：

• \(u\) 的区间和 \(sum(u)\)
• \(u\) 的增加量 \(add(u)\)

但是这两个标记是如何具体地维护从而支持区间加、区间和的呢？我们不知道

注意首先要想求出 \(u\) 的答案，我们需要考虑除了 \(u\) 本身被修改的影响之外的两个影响：

• \(u\) 的儿子对 \(u\) 答案的影响
• \(u\) 的祖先对 \(u\) 答案的影响

容易想到让 \(u\) 的标记维护第一个影响，然后在查询的时候对答案考虑第二个影响（查询时路过的节点都是当前查询节点的祖先，而 push_up 就相当于用儿子更新 \(u\)）

而由于询问时对于一个祖先需要方便地算出它对它的子树的影响，于是我们令 \(add(u)\) 表示 \(u\) 整个区间所有数都同步累加的增加量

此时 query 的祖先的影响就容易维护了，而 update 对该标记的影响也就是对所操作区间的 \(add\) 累加.

而由于节点内部需要记录所有儿子对 \(u\) 的影响，所以令 \(sum(u)\) 为考虑 \(u\) 子树内所有儿子对 \(u\) 影响的区间和

此时对于 \(sum\) 有两种维护方法：

• 一种方法：

  考虑通过 push_up 更新儿子对 \(u\) 的影响

  假设此时儿子的信息都已经搞定，也就是儿子的 \(sum\) 已经考虑了儿子及其子树的修改情况，现在我们需要用儿子的信息更新 \(u\) 的信息

  直接 \(sum(u)=sum(lc)+sum(rc)\) 即可

  而对于当前修改节点，修改 \(sum\) 即可

• 一种方法：

  update 时顺带把路过的节点的 \(sum\) 更新了，因为路过的节点一定是当前修改的节点的祖先，这次 update 一定影响到了这些点的区间和

注意虽然这两种方法的思想不同，一种是在回溯时更新，一种是在递归过程中更新，但是代码差异很小，同时这里建议写 push_up

然后在 query 时直接用 \(sum(u)\) 即可

所以 \(sum\) 这个标记是只考虑 \(u\) 这个单独的区间的内部情况的，也就是只考虑了 \(u\) 以及 其子树所有的修改情况，没有考虑其祖先的修改对它的影响

于是我们就推导出了标记永久化的过程.

总结：

注意这个问题中区间 \(u\) 维护了如下两个信息：

• 考虑 \(u\) 子树内的所有修改（增加）情况，\(u\) 的区间和 \(sum(u)\)
• 考虑 \(u\) 作为祖先，它的修改（增加）对儿子的答案的贡献 \(add(u)\)

更形象地，\(sum(u)\) 的范围是 \(u\) 的整棵子树，而 \(add(u)\) 的范围是 \(u\) 这一个节点，对儿子的答案的贡献

这种标记维护方式就是标记永久化的核心思想.

而这个方法的必要性和充分性都在前面的一步步推导中体现了.

模板题代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr int N = 1e5 + 10;
ll sum[N << 2], add[N << 2];
int n, m;

#define lc (u << 1)
#define rc ((u << 1) | 1)
#define mid ((l + r) >> 1)

void Up(int u, int l, int r) { sum[u] = sum[lc] + sum[rc] + 1ll * (r - l + 1) * add[u]; }
void build(int u, int l, int r) {
    if (l == r) return cin >> sum[u], void();
    build(lc, l, mid), build(rc, mid + 1, r), Up(u, l, r);
}
void Upd(int u, int l, int r, int x, int y, ll v) {
    if (y < l || r < x) return;
    if (x <= l && r <= y) return add[u] += v, sum[u] += 1ll * (r - l + 1) * v, void();
    Upd(lc, l, mid, x, y, v), Upd(rc, mid + 1, r, x, y, v), Up(u, l, r);
}
ll Qry(int u, int l, int r, int x, int y) {
    if (y < l || r < x) return 0ll;
    if (x <= l && r <= y) return sum[u];
    return Qry(lc, l, mid, x, y) + Qry(rc, mid + 1, r, x, y) + 1ll * (min(y, r) - max(x, l) + 1) * add[u];
}

int main() {
    ios::sync_with_stdio(false), cin.tie(nullptr);
    cin >> n >> m, build(1, 1, n);
    while (m--) {
        int op;
        cin >> op;
        if (op == 2) {
            int l, r;
            cin >> l >> r;
            cout << Qry(1, 1, n, l, r) << "\n";
        } else {
            int l, r; ll c;
            cin >> l >> r >> c;
            Upd(1, 1, n, l, r, c);
        }
    }
}

修改时改一路上的 sum、完全包含的 tag
查询时加一路上的 tag、完全包含的 sum

区间赋值、单点查询

假设前面两节你都看懂了

发现从上往下合并标记的时候有困难：如何合并？

发现只要保留最晚的赋值标记就可以

于是再维护一个时间戳，表示这个赋值标记的时间，合并时保留最晚的标记

区间加、区间赋值、区间和

维护 \(sum,add,tag,time\)，\(add\) 和 \(tag\) 任意时刻总是保留其一

区间加：若有 \(tag\)，\(tag\gets tag+x,time\gets now\)；否则 \(add\gets add+x\)

区间赋值：\(tag\gets x,time\gets now\)

区间和：合并标记时 \(add\) 和 \(tag\) 保留其一

• 有 \(tag\)：若当前节点有 \(tag\) 保留最晚的 \(tag\)，否则 \(tag\gets tag+add_u\)
• 无 \(tag\)：若当前节点有 \(tag\) 则 \(tag\gets tag_u+add,add\gets0\)，否则 \(add\gets add+add_u\)

算答案时类似

区间整除、区间加、区间最值

标记 \((a,b)\) 表示先加 \(a\) 再除以 \(b\)，记 \(*\) 为标记合并

区间加：\(\left\lfloor\dfrac{x+a}b\right\rfloor+p=\left\lfloor\dfrac{x+a+bp}b\right\rfloor\)

区间整除：\(\left\lfloor\dfrac{\left\lfloor\frac{x+a}b\right\rfloor}p\right\rfloor=\left\lfloor\dfrac{x+a}{bp}\right\rfloor\)

这就说明了 \((a,b)*(c,d)=(a+bc,bd)\)，没有交换律

网上有个说法是若能找到一个 \(a'\) 使得 \(a*b=b*a'\)，就可以做

具体是强制让儿子的标记比父亲的标记晚

但是这样不可行，复杂度是错的

于是这道题可以普通线段树做

区间加、区间和、区间和历史最大值

标记 \((a,b,c)\) 表示该区间加了 \(a\)，区间和为 \(b\)，区间和历史最大值为 \(c\)

区间加：\((a,b,c)\to(a+p,b+(r-l+1)\cdot p,\max(c,b+(r-l+1)\cdot p))\)

这是可以标记永久化的

区间 checkmax、区间 max、单点查

标记 \((a,b)\) 表示 checkmax 了 \(a\)，当前区间 \(\max=b\)

区间 checkmax：\((a,b)\to(\max(a,x),\max(b,x))\)

这也可以方便的标记永久化

区间加、区间乘、区间和

标记 \((a,b,c)\) 表示加、乘、和，钦定先乘再加（即 \(x\) 的真实值为 \(ax+b\)）

区间加：\((a,b,c)\to(a+x,b,c+x)\)

区间乘：\((a,b,c)\to(ax,bx,cx)\)

所以 \((a,b,c)*(d,e)=(ae+d,be,ce+d)\)

可以普通线段树做

---

不具有交换律的标记如何维护？

容易想到：对每个标记维护时间戳

从根节点走到当前节点一共经过了 \(\log n\) 个标记

用 set 维护从根节点到当前点的所有标记，是按时间从早到晚排序

到达相应节点后再把 set 上的标记一个个合并

时间复杂度 \(\mathcal O(n\log^2n)\)

因为它就是普通线段树区间查询再乘了个 set 的 log

而且实际上遍历 set 是 \(\mathcal O(n)\) 的，\(n\) 为 set 内元素个数

但是这个想法是错的，具体读者自证