2022.10.13 闲话

还是觉得 artalter 是莫反大仙，我给他一道题，他没注意到一个 Key Observation 然后硬干干出一个复杂度相同的做法来 .

发现有弦图高论可以从 KMP 的 next 数组计数原字符串 .

下面是 copy 的 EI 队长论文《浅谈函数最值的动态维护》 .

how EI's mind works?

目录

• 概述
  • 问题描述
  • Davenport–Schinzel 序列
  • 与问题的联系
• KTT 解决询问点单调递增的情况
  • 问题描述
  • Kinetic Tournament Tree (KTT)
  • 单点修改
• 势能分析表出线性情况的时间复杂度
  • 问题描述
  • 基本操作
  • 时间复杂度分析
  • $\{k\}$ 单调递增的情况
• 只加正数的第六分块
  • 问题描述
  • 基本操作
  • 时间复杂度分析

概述

问题描述

对于函数列 $f_i:\R\to \R$，支持对于函数列进行一些修改，以及整体查询最值，即给一个 $x$，求

$$\max_{j=1}^nf_j(x)$$

很自然的，可以想到维护 $\displaystyle F(x)=\max_{j=1}^nf_j(x)$，它是一个分段函数 .

考虑计算 $F(x)$ 最多分多少段，只考虑任意两个函数，如果段数不超过 $s+1$，其中 $s$ 是次数，即可得到 $F(x)$ 的段数的一个较紧的界 .

则考虑分段函数每一段属于哪个函数，记作序列 $\{a_m\}$，当然下标从 $0$ 开始，这样如果存在 $x,y$ 使得 $\{a\}$ 中存在长度超过 $s+1$ 的 $x,y$ 交替子序列，则 $\max\{f_x,f_y\}$ 的段数必然超过 $s+1$ .

那么可以引入 DS 序列：

Davenport–Schinzel 序列

定义

一个序列 $\{\sigma_m\}$ 是一个 $(n,s)$ 阶 Davenport–Schinzel 序列（简记作 $\operatorname{DS}(n,s)$ 序列），当且仅当 $\sigma_i\in[1,n]\cap\Z$ 且 :

• $\sigma$ 中任意相邻两项值不同 .
• 对于任意 $x\neq y$，任何 $x,y$ 构成的序列如果是 $\sigma$ 的子序列，则长度不超过 $s+1$ .

定理：

定理

记 $\lambda_s(n)$ 为 $\operatorname{DS}(n,s)$ 序列可能的最长长度，则有

$$\lambda_s(n)=\begin{cases}n&s=1\\2n-1&s=2\\2n\alpha(n)+O(n)&s=3\\\Theta(n2^{\alpha(n)})&s=4\\\Theta(n\alpha(n)2^{\alpha(n)})&s=5\\n2^{\alpha(n)^t/t!+O(\alpha(n)^{t-1})}&s\ge 6&\text{where }t=\left\lfloor\dfrac{s-2}2\right\rfloor\\\end{cases}$$

其中 $\alpha(n)$ 是反 Ackermann 函数 .

这个定理的证明十分有难度，这里就不再展开，可以从 EI 对于 $\lambda_3(n)=O(n\alpha(n))$ 的证明中窥得分晓 .

于是可知 $\lambda_s(n)$ 对于任意常数 $s$ 都是近线性的 .

这样段数就近乎是线性的了 .

与问题的联系

根据前面的成果，可以得到 $n$ 个最高 $s$ 次多项式的上包络线分段长度不超过 $\lambda_s(n)$ .

令分段函数在定义域外的部分，值都为 $-\infty$，则可以得到任意两个分段 $s$ 次函数是 $s+2$ 阶交替的（考虑定义域有交，则定义域中贡献 $s$ 阶，边界贡献 $2$ 阶）.

则 $n$ 个分段 $s$ 次函数最值上包络线分段长度不超过 $\lambda_{s+2}(n)$ .

下面有两种问题得到高效解决：

1. 不修改函数，只维护集合 .

   简要提一下做法：静态可以直接分治合并，询时二分，则预处理 $\Theta(\lambda_s(n)\log n)$，询问 $\Theta(m\log n)$ .

   如果要支持加函数就用经典的二进制分组，这样询问就是 $\Theta(n\log^2n)$，如果用分散层叠优化二分就还是 $\Theta(m\log n)$ .

2. 询问点单调递增，这样可以通过类似 Segment Tree Beats! 的思路设计，下面具体描述 .

KTT 解决询问点单调递增的情况

问题描述

对于 $n$ 个函数组成的函数列 $f_i:\R\to \R$，对于单调递增的 $\{x_q\}$ 序列中的每个元素 $x_k$，求整体的最值，即

$$\max_{j=1}^nf_j(x_k)$$

接下来的讨论中，假设处理的函数族是 $s$ 阶交替且可以在常数时间求出交替位置的函数 .

Kinetic Tournament Tree (KTT)

其实就是 Segment Tree Beats! 的思路套上这个 Davenport–Schinzel 序列的分析 .

用线段树维护区间中对于当前 $x$ 取到最大值的函数是哪个，$x$ 变化的时候暴力修改 .

每个点的分段个数是 $\lambda_s(n)$，线段树有 $\Theta(\log n)$ 层，暴力 DFS 修改又要一个 $\log$，于是时间复杂度 $\Theta(\lambda_s(n)\log^2n+q)$ .

单点修改

这个 KTT 可以直接推广到支持单点修改函数序列 .

由于 $\{x\}$ 单调递增，所以一个位置仍然可以看做只有一个函数，只不过这个函数分段。于是复杂度变为 $\Theta(\lambda_{s+2}(n+m)\log^2n+q)$ .

势能分析表出线性情况的时间复杂度

问题描述

对于序列 $\{k\}$，$\{b\}$，有三种操作：

1. 给 $l,r,x$，对于 $l\le i\le r$，令 $b_i\gets k_ix+b_i$ .
2. 给 $l,r,c,k',b'$，对于 $l\le i\le r$，令 $k_i\gets ck_i+k'$，$b_i\gets cb_i+b'$ .
3. 给 $l,r$，查询 $\displaystyle\max_{i\in[l,r]}b_i$ .

约定：$x,k_i,b_i,c>0$ .

基本操作

相当于对于每个点维护一个函数 $f_i(x)=k_ix+b_i$，操作 1 就是区间 $x$ 增加，而且注意到被操作 2 完全覆盖的区间可以发现 $k,b$ 的大小关系都没有变化 .

于是考虑随便两个点 $k_1x+b_1$ 和 $k_2x+b_2$，其中 $b_i>b_2$，$k_1<k_2$ 同时经过操作 2 后会发生什么 . 可以发现 $x$ 至少需要增加 $\dfrac{b_1-b_2}{k_2-k_1}$ 才会使得大小关系改变，也就是说修改完之后大小关系是不会改变的！

于是考虑线段树维护区间的 $x,k,b$ 什么变化，以及最大值在哪里取到，以及 $x$ 再整体增加多少就会使得最大值切换 .

主要的问题时操作 1 时如果要切换最大值需要递归下去换，这个的复杂度分析如下 .

时间复杂度分析

根据前面的讨论，注意到切换最大值的时候一定是从斜率小的换成斜率大的 .

定义一个非叶子节点组成的集合 $\mathcal P$，对于一个非叶子节点 $u$，如果 $u$ 保留目前取值较大的儿子所对于的直线斜率严格小于另一个儿子，则 $u\in\mathcal P$ .

定义势函数 $\displaystyle\Phi=\sum_{u\in\mathcal P}\operatorname{depth}(u)$，其中 $\operatorname{depth}(u)$ 是点 $u$ 在线段树上的深度，根节点的深度为 $1$（根节点深度其实不怎么重要，但是为了严密还是提一下）.

于是一次切换 $\Phi$ 至少减小 $1$，因为一次对 $u$ 的切换会使得 $\Phi$ 必然减少 $\operatorname{depth}(u)$，并有可能增加 $\operatorname{depth}(\operatorname{father}(u))$，也就是至少减小 $1$ .

那么考虑两种操作只有被访问的节点可能加入 $\mathcal P$，于是因为只会访问 $O(\log n)$ 个点于是只会增加 $O(\log^2n)$ 的势能 .

加上初始的 $O(n\log n)$ 势能，可以得到总复杂度为 $O(n\log^2n+m\log^3n+q\log n)$ .

$\{k\}$ 单调递增的情况

注意到此时切换只能从左儿子切换到右儿子 . 另外，对于一个点，如果它子树的最大值已经在右儿子了，那么打标记的时候即使左儿子被切换了，它也不会被切换，于是可以直接设 $\Phi$ 为最大值位于左子树的点数，从而比上面少一个 log .

时间复杂度 $O(n\log n+m\log^2 n+q\log n)$ .

只加正数的第六分块

问题描述

维护一个整数序列 $\{a\}$，支持：

1. 给 $l,r,x$，对于所有 $l\le i\le r$，令 $a_i\gets a_i+x$ .
2. 给 $l,r$，询问区间 $[l,r]$ 的最大子段和（可以为空）.

操作 1 中所有 $x>0$ .

先放份代码实现，免得有些 gtm1514 说我口胡

Code

const int N = 444444;
const ll INF = 0x7f7f7f7f7f7f7f7fll;
int n, a[N], q;
struct line
{
	int k; ll b;
	line() = default;
	line(int K, ll B) : k(K), b(B){}
	line operator + (const line& rhs)const{return line(k + rhs.k, b + rhs.b);}
};
pair<line, ll> max(line a, line b)
{
	if ((a.k < b.k) || ((a.k == b.k) && (a.b < b.b))) swap(a, b);
	if (a.b >= b.b) return make_pair(a, INF);
	return make_pair(b, (b.b - a.b) / (a.k - b.k));
}
struct SMT
{
#define ls (u << 1)
#define rs (u << 1 | 1)
#define mid ((l + r) >> 1)
	struct Node
	{
		int l, r;
		ll x, tag;
		line sum, lmax, rmax, totmax;
		Node() = default; 
		Node(line a, line b, line c, line d, ll e = INF, ll f = 0) : lmax(a), rmax(b), totmax(c), sum(d), x(e), tag(f){} 
		Node operator + (const Node& rhs) const
		{
			Node ans; ans.sum = sum + rhs.sum; ans.x = min(x, rhs.x);
			auto _ = max(lmax, sum + rhs.lmax);
			ans.lmax = _.first; chkmin(ans.x, _.second);
			_ = max(rhs.rmax, rmax + rhs.sum);
			ans.rmax = _.first; chkmin(ans.x, _.second);
			_ = max(totmax, rhs.totmax);
			chkmin(ans.x, _.second);
			_ = max(_.first, rmax + rhs.lmax);
			ans.totmax = _.first; chkmin(ans.x, _.second);
			return ans;
		}
		Node& operator = (const Node& rhs)
		{
			x = rhs.x;
			sum = rhs.sum; lmax = rhs.lmax; rmax = rhs.rmax; totmax = rhs.totmax;
			return *this;
		}
	}tr[N << 2];
	inline void pushup(int u){tr[u] = tr[ls] + tr[rs];}
	inline void swit(int u, ll w)
	{
		if (w > tr[u].x)
		{
			ll t = w + tr[u].tag; tr[u].tag = 0;
			swit(ls, t); swit(rs, t);
			pushup(u);
			return ;
		}
		tr[u].tag += w; tr[u].x -= w;
		tr[u].lmax.b += tr[u].lmax.k * w;
		tr[u].rmax.b += tr[u].rmax.k * w;
		tr[u].totmax.b += tr[u].totmax.k * w;
		tr[u].sum.b += tr[u].sum.k * w;
	}
	inline void pushdown(int u)
	{
		if (!tr[u].tag) return ;
		swit(ls, tr[u].tag); swit(rs, tr[u].tag);
		tr[u].tag = 0;
	}
	void build(int u, int l, int r)
	{
		tr[u].l = l; tr[u].r = r;
		if (l == r){auto _ = line(1, a[l]); tr[u] = Node(_, _, _, _);return ;}
		build(ls, l, mid); build(rs, mid+1, r);
		pushup(u);
	}
	void change(int u, int L, int R, int x)
	{
		int l = tr[u].l, r = tr[u].r;
		if (inrange(l, r, L, R)){swit(u, x); return ;}
		pushdown(u);
		if (L <= mid) change(ls, L, R, x);
		if (R > mid) change(rs, L, R, x);
		pushup(u); 
	}
	Node query(int u, int L, int R)
	{
		int l = tr[u].l, r = tr[u].r;
		if (inrange(l, r, L, R)) return tr[u];
		pushdown(u);
		if (R <= mid) return query(ls, L, R);
		if (L > mid) return query(rs, L, R);
		return query(ls, L, R) + query(rs, L, R);
	}
#undef mid
#undef rs
#undef ls 
}T;
int main()
{
	scanf("%d%d", &n, &q);
	for (int i=1; i<=n; i++) scanf("%d", a+i);
	T.build(1, 1, n);
	int opt, l, r, x;
	while (q--)
	{
		scanf("%d%d%d", &opt, &l, &r);
		if (opt == 1){scanf("%d", &x); T.change(1, l, r, x);}
		else printf("%lld\n", max(0ll, T.query(1, l, r).totmax.b));
	}
	return 0;
}

基本操作

我们有一个非常经典的维护最大子段和的分治做法（小白逛公园），维护区间和 $sum$，前缀最大子段和 $lmax$，后缀最大子段和 $rmax$，和真正的最大子段和 $totmax$ .

转移即为

$$\begin{aligned} sum &= ls.sum + rs.sum\\ lmax &= \max(ls.lmax, ls.sum+rs.lmax)\\ rmax &= \max(rs.rmax, rs.sum+ls.rmax)\\ totmax &= \max(ls.totmax, rs.totmax, ls.rmax + rs.lmax) \end{aligned}$$

全都是关于区间加的一次函数 .

这样根据前面的线性情况做法，类似的去做就好了 .

其实 KTT 部分还是一致的，问题在于势能分析 .

时间复杂度分析

根据人类智慧，构造势函数的方法如下：

令 $r(u,para)$ 表示：

• 对于 $r(u,lmax)$ 和 $r(v,rmax)$，对于该变量的决定式 $f(x)=\max\{a(x),b(x)\}$，$r(u,para)$ 表示当前 $a,b$ 中斜率大于 $f$ 的斜率的直线数量乘 $\operatorname{depth}(u)^2$ .
• 对于 $r(u,totmax)$，对于该变量的决定式 $f(x)=\max\{a(x),b(x),c(x)\}$，$r(u,para)$ 表示当前 $a,b,c$ 中斜率大于 $f$ 的斜率的直线数量乘 $\operatorname{depth}(u)$ .

$\operatorname{depth}(u)$ 定义同上 .

P.S. 所谓「决定式」其实就是前面的转移抽象化一下 .

定义势函数 $\displaystyle\Phi=\sum_u\sum_{para}r(u,para)$ .

于是考虑一些操作对势能的贡献：

• 初始势能：给 $lmax$ 贡献势能 $O(n\log^2n)$，给 $totmax$ 贡献势能 $O(n\log n)$ .
• 一次修改：给 $lmax$ 贡献势能 $O(\log^3n)$，给 $totmax$ 贡献势能 $O(\log^2n)$ .

再根据人类智慧，发现 $lmax$ 转移点单调不降，于是 $lmax,rmax$ 的总切换次数就是 $O(n\log n)$ 的，贡献给 $totmax$ 的势能就是 $O(n\log^2n)$ 的了 .

于是时间复杂度为 $O((n+q)\log^3n)$ .