从《楼房重建》出发浅谈一类使用线段树维护前缀最大值的算法

首先需要申明的是，真的是浅谈，因为我对这个算法的认识还是非常低的。

既然是从《楼房重建》出发，那么当然是先看看这道题：

[清华集训2013]楼房重建

bzoj 链接

题意简述：

有 \(n\) 栋楼，第 \(i\) 栋的高度为 \(H_i\)，也就是说第 \(i\) 栋楼可以抽象成一条两端点为 \((i, 0)\) 和 \((i, H_i)\) 的线段。

初始时 \(H_i\) 均为 \(0\)，要支持动态修改单点的 \(H_i\)。

每次询问从 \(O(0, 0)\) 点可以看到多少栋楼房。

能看到一栋楼 \(i\) 当且仅当 \(H_i > 0\) 且 \((0, 0)\) 与 \((i, H_i)\) 的连线上不经过其它楼房。

题解：

令 \(s_i = H_i / i\)，即 \((0, 0)\) 到 \((i, H_i)\) 的斜率，再定义 \(s_0 = 0\)。

则一栋楼房 \(i\) 能被看见，当且仅当 \(\displaystyle \max_{j = 0}^{i - 1} \{ s_j \} < s_i\)，也就是说它是 \(s_i\) 的前缀严格最大值。

直接进入正题，我们使用线段树维护这个东西。

考虑线段树上的某一个节点表示的区间 \([l, r]\)，则保存的信息有：

这个区间中的 \(s_i\) 的最大值。
仅考虑这个区间时的上述答案，也就是不考虑 \([1, l - 1]\) 对本区间的影响，而是看作整体的前缀最大值个数。

可以发现只有单点修改，那么我们只需考虑递归到底层节点后，一层层往上维护信息即可。

当前考虑一个节点 \(i\)，假设 \(i\) 的子树内的所有节点（除了 \(i\) 本身）的信息都维护好了，需要维护节点 \(i\) 的信息。

信息 1 是容易维护的，只要两个子树取 \(\max\) 即可。

但是信息 2 如果直接用两个子树信息相加，是错误的，因为没有考虑左子树向右子树的贡献。

进一步分析：可以发现直接继承左子树的信息是没问题的，但是右子树信息不能直接继承。

考虑引入一个新函数：\(\mathrm{calc}(i, pre)\)，它的作用是返回 \(i\) 子树内，考虑了前缀最大值 \(pre\) 的影响后的答案。

为了方便表述，把信息 1 记做 \(\boldsymbol{\max[i]}\)，把信息 2 记做 \(\boldsymbol{\mathrm{cnt}[i]}\)，则它的伪代码如下：

\(\displaystyle \begin{array}{l} \textbf{def: } \mathrm{calc}(i, pre) \\ \qquad \textbf{if } (i \text{ is a leaf node}) \\ \qquad \qquad \textbf{return } {\color{green}{[\max[i] > pre]}} \\ \qquad \textbf{else} \\ \qquad \qquad \textbf{if } (\max[\mathrm{leftchild}[i]] > pre) \\ \qquad \qquad \qquad \textbf{return } {\color{blue}{\mathrm{calc}(\mathrm{leftchild}[i], pre)}} + {\color{red}{(\mathrm{cnt}[i] - \mathrm{cnt}[\mathrm{leftchild}[i]])}} \\ \qquad \qquad \textbf{else} \\ \qquad \qquad \qquad \textbf{return } {\color{blue}{0}} + {\color{red}{\mathrm{calc}(\mathrm{rightchild}[i], pre)}} \\ \qquad \qquad \textbf{endif.} \\ \qquad \textbf{endif.} \\ \textbf{enddef.} \end{array}\)

其中蓝色的是左子树贡献，红色的是右子树贡献。

当当前节点 \(i\) 是叶节点的时候，贡献很容易计算。
否则考虑左右子树的贡献分别计算，分成两种情况考虑：

\(pre\) 小于左子树的最大值：
此时对右子树来说，\(pre\) 是无意义的，所以递归进左子树，右子树的贡献直接用“全部”减“左子树”计算即可。
\(pre\) 大于等于左子树的最大值：
此时对左子树来说，就不可能贡献任何前缀最大值了，所以贡献为 \(0\)，然后递归进右子树即可。

可以看出，调用一次 \(\mathrm{calc}\) 函数递归的时间复杂度为 \(\mathcal O (\log n)\)，因为每次只递归进一个孩子。

每次维护当前节点的答案时，只要令 \(\mathrm{cnt}[i] = \mathrm{cnt}[\mathrm{leftchild}[i]] + \mathrm{calc}(\mathrm{rightchild}[i], \max[\mathrm{leftchild}[i]])\) 即可。

可以发现有 \(\mathcal O (\log n)\) 个节点要调用 \(\mathrm{calc}\) 函数，所以一次单点修改的时间复杂度为 \(\mathcal O (\log^2 n)\)。

至此可以写出本题的代码：

#include <cstdio>

typedef long long LL;
const int MN = 100005, MS = 1 << 18 | 7;

int N, Q, H[MN];

inline bool gt(int p1, int p2) { // s[p1] is greater than s[p2]
    if (!p2) return H[p1];
    return (LL)H[p1] * p2 > (LL)H[p2] * p1;
}
#define li (i << 1)
#define ri (li | 1)
#define mid ((l + r) >> 1)
#define ls li, l, mid
#define rs ri, mid + 1, r
int id[MS], cnt[MS];
void Build(int i, int l, int r) {
    id[i] = l, cnt[i] = 1;
    if (l == r) return ;
    Build(ls), Build(rs);
}
int Calc(int i, int l, int r, int p) {
    if (l == r) return gt(l, p);
    if (gt(id[li], p)) return Calc(ls, p) + (cnt[i] - cnt[li]);
    else return 0 + Calc(rs, p);
}
void Mdf(int i, int l, int r, int p) {
    if (l == r) return ;
    if (p <= mid) Mdf(ls, p);
    else Mdf(rs, p);
    id[i] = gt(id[ri], id[li]) ? id[ri] : id[li];
    cnt[i] = cnt[li] + Calc(rs, id[li]);
}

int main() {
    scanf("%d%d", &N, &Q);
    Build(1, 1, N);
    while (Q--) {
        int p, x;
        scanf("%d%d", &p, &x);
        H[p] = x, Mdf(1, 1, N, p);
        printf("%d\n", Calc(1, 1, N, 0));
    }
    return 0;
}

但是，我们注意到一个很关键的性质：

当 \(pre\) 小于左子树的最大值时，右子树对当前节点的贡献，是通过减法计算的。

也就是说这个信息要满足一定程度上的可减性。

但是有很多信息是不满足可减性的，比如 \(\max, \min\)、按位与、按位或等。

为了能让这种线段树适应更一般的情况，我们修改维护的信息的意义：

仍然维护这个区间中的 \(s_i\) 的最大值。
此时并不是维护区间的答案，而是仅考虑该区间的影响后，却又只统计右子树的答案。
也就是说令当前节点对应的区间为 \([l, r]\)，区间中点为 \(mid\)，则：
维护的答案是，只考虑 \(g_l \sim g_r\) 时，在区间 \([mid + 1, r]\) 中的答案。

仍然把信息 1 记做 \(\max[i]\)，把信息 2 记做 \(\mathrm{cnt}[i]\)。

对于叶节点，信息 2 则看作是未定义的。

然后考虑维护当前节点的信息（也就是 Pushup），仍然引入一个 \(\mathrm{calc}(i, pre)\) 函数。

此时它的作用仍然是计算在 \(pre\) 的影响下的整个区间内的答案（而不是右子树），也就是说它的意义没有改变。

它的伪代码如下：

\(\displaystyle \begin{array}{l} \textbf{def: } \mathrm{calc}(i, pre) \\ \qquad \textbf{if } (i \text{ is a leaf node}) \\ \qquad \qquad \textbf{return } {\color{green}{[\max[i] > pre]}} \\ \qquad \textbf{else} \\ \qquad \qquad \textbf{if } (\max[\mathrm{leftchild}[i]] > pre) \\ \qquad \qquad \qquad \textbf{return } {\color{blue}{\mathrm{calc}(\mathrm{leftchild}[i], pre)}} + {\color{red}{\mathrm{cnt}[i]}} \\ \qquad \qquad \textbf{else} \\ \qquad \qquad \qquad \textbf{return } {\color{blue}{0}} + {\color{red}{\mathrm{calc}(\mathrm{rightchild}[i], pre)}} \\ \qquad \qquad \textbf{endif.} \\ \qquad \textbf{endif.} \\ \textbf{enddef.} \end{array}\)

其实变化并不大，因为此时 \(\mathrm{cnt}[i]\) 记录的直接就是右子树信息，所以不需要做减法。

每次维护当前节点的答案时，只要令 \(\mathrm{cnt}[i] = \mathrm{calc}(\mathrm{rightchild}[i], \max[\mathrm{leftchild}[i]])\) 即可。

其实更好写了，代码如下：

#include <cstdio>

typedef long long LL;
const int MN = 100005, MS = 1 << 18 | 7;

int N, Q, H[MN];

inline bool gt(int p1, int p2) { // s[p1] is greater than s[p2]
    if (!p2) return H[p1];
    return (LL)H[p1] * p2 > (LL)H[p2] * p1;
}
#define li (i << 1)
#define ri (li | 1)
#define mid ((l + r) >> 1)
#define ls li, l, mid
#define rs ri, mid + 1, r
int id[MS], cnt[MS];
void Build(int i, int l, int r) {
    id[i] = l, cnt[i] = 1;
    // if i is a leaf node, then cnt[i] can be any value.
    // but here, for convenience, we just let it be 1.
    if (l == r) return ;
    Build(ls), Build(rs);
}
int Calc(int i, int l, int r, int p) {
    if (l == r) return gt(l, p);
    if (gt(id[li], p)) return Calc(ls, p) + cnt[i];
    else return 0 + Calc(rs, p);
}
void Mdf(int i, int l, int r, int p) {
    if (l == r) return ;
    if (p <= mid) Mdf(ls, p);
    else Mdf(rs, p);
    id[i] = gt(id[ri], id[li]) ? id[ri] : id[li];
    cnt[i] = Calc(rs, id[li]);
}

int main() {
    scanf("%d%d", &N, &Q);
    Build(1, 1, N);
    while (Q--) {
        int p, x;
        scanf("%d%d", &p, &x);
        H[p] = x, Mdf(1, 1, N, p);
        printf("%d\n", Calc(1, 1, N, 0));
    }
    return 0;
}

[CodeForces 671E]Organizing a Race

CF 链接

题意简述：

题意的抽象过程太复杂了，这里仅考虑抽象后的模型：

给出两个长度为 \(n\) 的整数序列 \(a_i, b_i\)，令 \(\displaystyle c_i = a_i + \max_{j = 1}^{i} \{ b_j \}\)。

你需要动态维护整个数组中满足 \(\boldsymbol{c_i \le k}\) 的最大下标 \(\boldsymbol{i}\)，需要支持 \(b_i\) 的区间加减的修改操作。

而 \(a_i\) 是不会变的（不过，如果加一个 \(a_i\) 的区间加减操作，也可以做）。

题解：

可以发现，因为这里要维护的东西变成 \(c_i\) 的区间 \(\min\) 了，没有可减性，所以不能用第一种方法。

考虑在线段树的每个节点维护三个信息：

这个区间中 \(a_i\) 的最小值，记做 \({a\mathrm{min}}\)。
这个区间中 \(b_i\) 的最大值，记做 \({b\mathrm{max}}\)。
仅考虑该区间时，在右子树内的答案，记做 \(\mathrm{ans}\)。

因为是区间修改 \(b_i\)，所以这里需要用到线段树懒标记的方法，具体不展开讲。

此时需要面对两个问题，下传标记（Pushdown）和维护信息（Pushup）。

对于打标记，当一个节点被打上区间 \(b\) 加上 \(x\) 的标记的时候，只要把 \({b\mathrm{max}}\) 和 \(\mathrm{ans}\) 都加上 \(x\) 即可。

那么最重要的问题仍然是维护信息（Pushup），仍然是写出类似函数 \(\mathrm{calc}(i, pre)\) 的伪代码：

\(\displaystyle \begin{array}{l} \textbf{def: } \mathrm{calc}(i, pre) \\ \qquad \textbf{if } (i \text{ is a leaf node}) \\ \qquad \qquad \textbf{return } {\color{green}{{a\mathrm{min}}[i] + \max \{ pre, {b\mathrm{max}}[i] \} }} \\ \qquad \textbf{else} \\ \qquad \qquad \textbf{if } ({b\mathrm{max}}[\mathrm{leftchild}[i]] > pre) \\ \qquad \qquad \qquad \textbf{return } \min \{ {\color{blue}{\mathrm{calc}(\mathrm{leftchild}[i], pre)}}, {\color{red}{\mathrm{ans}[i]}} \} \\ \qquad \qquad \textbf{else} \\ \qquad \qquad \qquad \textbf{return } \min \{ {\color{blue}{{a\mathrm{min}}[\mathrm{leftchild}[i]] + pre}}, {\color{red}{\mathrm{calc}(\mathrm{rightchild}[i], pre)}} \} \\ \qquad \qquad \textbf{endif.} \\ \qquad \textbf{endif.} \\ \textbf{enddef.} \end{array}\)

对于当前节点 \(i\) 是叶节点的情况显然。
假如 \(pre < {b\mathrm{max}}[\mathrm{leftchild}[i]]\)，那么对右子树来说直接继承答案即可，然后递归进左子树。
否则左子树中所有的 \(b_i\) 都 \(\le pre\)，那么 \(b\) 的前缀 \(\max\) 也自然是都等于 \(pre\)，只要考虑 \(a_i\) 的最小值即可。

最后需要求整个数组中满足 \(c_i \le k\) 的最大下标 \(i\)，一般情况下可以直接线段树上二分，但是这里比较特殊。

考虑一个新函数 \(\mathrm{solve}(i, pre)\)，表示当前缀最大值为 \(pre\) 时，线段树中节点 \(i\) 对应的区间 \(c_i \le k\) 的最大下标 \(i\)。

如果 \({b\mathrm{max}}[\mathrm{leftchild}[i]] > pre\)，也就是说 \(pre\) 影响不到右子树：
那么，如果 \(\mathrm{ans}[i] \le k\)，就递归进右子树，否则递归进左子树。
复杂度显然是 \(\mathcal O (\log n)\)。
如果 \({b\mathrm{max}}[\mathrm{leftchild}[i]] \le pre\)，也就是说左子树完全被 \(pre\) 控制了：
先递归进右子树查询，如果没查询到，则考虑左子树因为被 \(pre\) 控制了，限制变为 \(a_i + pre \le k\)。
则移项得到 \(a_i \le k - pre\)，在左子树内是一个正常的线段树上二分的子问题（需要新写一个函数查询）。
因为只会进行 \(\mathcal O (\log n)\) 次线段树上二分，所以时间复杂度为 \(\mathcal O (\log^2 n)\)。

至此我们在 \(\mathcal O (n \log^2 n)\) 的时间复杂度内解决了这个问题。