P8600 [蓝桥杯 2013 省 B] 连号区间数 题解

析合树是一种连续段数据结构。

引入：

给定排列 $\{P_n\}$，求值域连续的段的个数。

概念

排列 是排列。

连续段 是值域连续的段，满足集合运算。

值域区间 是连续段值域的区间。

本原段 是不与其他连续段部分相交的连续段。

连续段集 $I_p$，本原段集 $M_p$。

形式化的，

定义序列 $P$ 是 $n$ 阶排列 $\iff |P|=n$ 且 $\mathrm{\forall }i\in [1,n],i\in P$。

定义 $(P,[l,r])$ 是连续段 $\iff \nexists x,z\in [l,r],y\notin [l,r],P_x<P_y<P_z$。

连续段 $(P,[l,r])$ 满足 $[l,r]$ 上的集合运算。

定义 $(P,[l,r])$ 的值域区间为 $[\underset{i=l}{\overset{r}{min}}{P}_i,\underset{i=l}{\overset{r}{max}}{P}_i]$。

定义连续段集 $I_p=\{A|A\text{是连续段}\}$。

定义连续段 $X$ 是本原段 $\iff \mathrm{\forall }A\in I_p,X\cap A=(P,\varnothing )$ 或 $X\subseteq A$ 或 $A\subseteq X$。

定义本原段集 $M_p=\{A|A\text{是本原段}\}$。

析点与合点

析合树的点集是 $M_p$。

概念

节点 $u$ 的 值域区间 为 $[u_l,u_r]$。

节点 $u$ 的 子节点序列 $S_u$ 是 $u$ 的极长真子连续段序列。

节点 $u$ 的 子节点排列 $P_u$ 是 $S_u$ 按值域区间左端点离散化的结果。

节点 $u$ 是 合点 当且仅当 $P_u$ 有序。

节点 $u$ 是 析点 当且仅当 $u$ 不是合点。

形式化的，

定义节点 $u$ 的值域区间为 $[u_l,u_r]$。

定义节点 $u$ 的子节点序列 $S_u=\{v|v⫋u,\nexists w⫋u,v⫋w\}$，且按 $v$ 的左端点排序。

注意，$v$ 的左端点不是 $v$ 的值域区间左端点。

定义节点 $u$ 的子节点排列 $P_{u,i}=|\{v_l\le {S_{u,i}}_l|v\in S_u\}|$。

定义节点 $u$ 是合点 $\iff \mathrm{\forall }i\in [1,|S_u|],P_{u,i}=i$ 或 $\mathrm{\forall }i\in [1,|S_u|],P_{u,i}=|S_u|-i+1$。

定义节点 $u$ 是析点 $\iff u$ 不是合点。

性质

$u$ 的子节点的并是 $u$。显然。

$u$ 是合点当且仅当 $S_u$ 的子段构成连续段。显然。

$u$ 是析点当且仅当 $S_u$ 的多元素真子段不构成连续段。

证明：若命题不成立，则 $S_u$ 上构成连续段的极长真子段构成本原段，而此本原段未在析合树中出现。

形式化的，

$\bigcup _{v\in S_u}v=u$。

$u$ 是合点 $\iff \mathrm{\forall }[l,r]\subseteq [1,|S_u|],\bigcup _{i=l}^r{S}_{u,i}\in I_p$。

$u$ 是析点 $\iff \mathrm{\forall }[l,r]\subseteq [1,|S_u|],l<r,\bigcup _{i=l}^r{S}_{u,i}\notin I_p$。

建树

可以用 增量法 $O(n\log n)$ 建析合树。

将 $P_i$ 依次加入析合树，用一个栈维护 $P_j|j\in [1,i)$ 形成的析合森林。

策略

维护当前节点 $u$（初值为 $(P,[i,i])$），考虑 $u$ 与栈内节点的合并情况。

1. $u$ 能成为栈顶节点的子节点 $\iff$ 栈顶节点是合点且 $u$ 与栈顶节点的最右子节点能合并成连续段，令 $u$ 成为栈顶节点的子节点，然后令 $u\leftarrow$ 栈顶节点。
2. $u$ 不能成为栈顶节点的子节点，令 $u$ 与栈顶若干节点合并成连续段 $v$ 且 $|S_v|$ 最小。考虑 $v$ 的类型，容易发现此时 $v$ 是合点 $\iff |S_v|=2$。令 $u\leftarrow v$。
3. 重复上述方案直到不能进行（即找不到 2. 中合法的 $v$），将 $u$ 入栈。

（来自 CF，对 $\{9,1,10,3,2,5,7,6,8,4\}$ 建析合树）

根据上述策略，我们需要快速判断 $u$ 与一些点能否合并成连续段，即判断任意后缀 $[j,i]|j\in [1,i)$ 是否连续段。

子问题

考虑如何快速判断 $[j,i]|j\in [1,i)$ 是否连续段。

$P$ 是排列，所以 $[j,i]$ 是连续段当且仅当 $\underset{j\le k\le i}{max}-\underset{j\le k\le i}{min}=i-j$。

维护 $Q_j=\underset{j\le k\le i}{max}-\underset{j\le k\le i}{min}-i+j|j\in [1,i)$，则 $[j,i]$ 是连续段当且仅当 $Q_j=0$。

考虑更新 $i$ 时如何快速更新 $Q$。

在 $\underset{j\le k\le i}{max}-\underset{j\le k\le i}{min}-i+j$ 中，$j$ 是不变的，每次更新 $i$ 对 $Q_j$ 的贡献减一，最值的贡献不好维护。

设 $P_i$ 更新了 $B_i$ 个后缀最值的位置，注意到 $\sum _{i=1}^n{B}_i=O(n)$（单调栈结论）。

用单调栈维护后缀最值的位置，以后缀最小值为例。

维护单调递增的栈 $x$。不难发现 $P_{x_i}$ 是后缀 $[j,i]|j\in (x_{i-1},x_i]$ 的最小值。

$x_i$ 出栈时失去对 $Q_j|j\in (x_{i-1},x_i]$ 的贡献，所以 $Q_j|j\in (x_{i-1},x_i]\leftarrow Q_j+P_{x_i}$。

$i$ 入栈时获得对 $Q_j|j\in (x_{top},i]$ 的贡献，所以 $Q_j|j\in (x_{top},i]\leftarrow Q_j-P_i$。

后缀最大值同理。

关于本题

考虑析合树内每个点的贡献。

由合点的性质，若 $u$ 是合点，则 $S_u$ 的任意子段构成连续段，即 $u$ 的贡献为 $(\genfrac{}{}{0ex}{}{|S_u|}{2})$。

由析点的性质，若 $u$ 是析点，则 $S_u$ 的任意多元素子段不构成连续段，即 $u$ 的贡献为 $1$。

注意到 $|M_p|=O(n)$，所以时间复杂度 $O(n\log n)$。

#include <cstdio>
#include <vector>
#define A(u, v) u->c.push_back(v)
using namespace std;
int n, L, X, Y, a[50050], x[50050], y[50050];
long long q;
struct S
{
    int l, r;
    bool b;
    vector<S *> c;
} * u, *f, *s[50050];
struct T
{
    T *l, *r;
    int s, t, v, x;
    T(int p, int q) : s(p), t(q), v(0), x(0) {}
    void f(int p)
    {
        v += p;
        x += p;
    }
    void u() { v = min(l->v, r->v); }
    void d()
    {
        l->f(x);
        r->f(x);
        x = 0;
    }
} * r;
void D(S *p)
{
    q += p->b ? 1ll * p->c.size() * (p->c.size() - 1) >> 1 : 1;
    for (auto c : p->c)
        D(c);
}
void B(int s, int t, T *&p)
{
    p = new T(s, t);
    if (s != t)
    {
        int m = p->s + p->t >> 1;
        B(s, m, p->l);
        B(m + 1, t, p->r);
        p->u();
    }
}
void M(int l, int r, int x, T *p)
{
    if (l <= p->s && p->t <= r)
        return p->f(x);
    p->d();
    int m = p->s + p->t >> 1;
    if (l <= m)
        M(l, r, x, p->l);
    if (r > m)
        M(l, r, x, p->r);
    p->u();
}
bool Q(int l, T *p)
{
    if (p->s == p->t)
        return !p->v;
    p->d();
    int m = p->s + p->t >> 1;
    return l <= m ? Q(l, p->l) : Q(l, p->r);
}
int Z(T *p)
{
    if (p->s == p->t)
        return p->s;
    p->d();
    int m = p->s + p->t >> 1;
    return p->l->v ? Z(p->r) : Z(p->l);
}
int main()
{
    scanf("%d", &n);
    B(1, n, r);
    for (int i = 1; i <= n; ++i)
        scanf("%d", a + i);
    for (int i = 1, p, o; i <= n; ++i)
    {
        while (X && a[i] <= a[x[X]])
            M(x[X - 1] + 1, x[X], a[x[X]], r), --X;
        while (Y && a[i] >= a[y[Y]])
            M(y[Y - 1] + 1, y[Y], -a[y[Y]], r), --Y;
        M(x[X] + 1, i, -a[i], r);
        M(y[Y] + 1, i, a[i], r);
        x[++X] = y[++Y] = i;
        u = new S{i, i, 0};
        p = Z(r);
        while (L && s[L]->l >= p)
            if (s[L]->b && Q(s[L]->c.back()->l, r))
                s[L]->r = i, A(s[L], u), u = s[L--];
            else
            {
                f = new S{0, i, Q(s[o = L]->l, r)};
                while (!Q(s[L]->l, r))
                    --L;
                for (int j = L; j <= o; ++j)
                    A(f, s[j]);
                f->l = s[L--]->l;
                A(f, u);
                u = f;
            }
        s[++L] = u;
        M(1, i, -1, r);
    }
    return D(s[1]), printf("%lld", q), 0;
}