Segment Tree Beats 小记

关注

原创 2022-02-08 09:44:40 443 阅读 AI 写同款· GEO 优化 ›

Segmentree beats!---吉如一线段树学习笔记 jry老师太牛了!! 本文为学习吉如一老师 Segmenttree beats 一文后有感而发qwq I 给定一个长度为n的数列A，接下来有m次操作： • 区间[l,r][l,r][l,r]中的所有数变成min(Ai,x)min(Ai,x)min(Ai,x) • 询问区间[l,r][l,r][l,r]中所有数的和记录区间最大值和次大值,如果小于次大值就暴力递归即可证明: 会发现我们每次花费O(log⁡n)O(\log n)O(logn)的时间使得两个数变得相同,因此总复杂度就是O(mlog⁡n+nlog 阅读详情

就拿洛谷的模板题来举例吧。

我们先简化一下各个操作的定义：

操作 $1$ ：区间加 $k$ ；

操作 $2$ ：区间同 $v$ 取 $\min$ ；

操作 $3$ ：区间求和；

操作 $4$ ：区间求最大值；

操作 $5$ ：区间求最大的历史最大值。

其中操作 $2$ 和 $5$ 是比较复杂的，所以我们需要用到吉老师发明的线段树—— $S e g m e n t T r e e B e a t s$ 。

（注：所有的操作通过势能分析法可得总时间复杂度为 $O(m log_2 n)$ ，具体证明可以参考原论文）

~~（显然是笔者太菜了不会）~~

在分析操作之前，我们定义一些变量（指线段树节点上储存的变量）：

~~（强烈建议拿草稿纸记录一下）~~

$s u m a$ —— 区间内 $A_i$ 的和；

$m x a$ —— 区间内 $A_i$ 的最大值；

$c n t m x$ —— 区间内 $A_i$ 最大值的出现次数（方便求和时最大值与其它值分别计算）；

$c m x a$ —— 区间内 $A_i$ 的严格次大值（这个在操作 $2$ 中会用到，实质是为了维护 $c n t m x$ ）；

$m x b$ —— 区间内 $B_i$ 的最大值；

然后再定义一些标记（同上）：

$t a g a m x$ —— 区间内 $A_i$ 的最大值的加法标记；

$t a g a n m x$ —— 区间内非 $A_i$ 最大值的加法标记；

$t a g b m x$ —— 注意这并不是区间内 $B_i$ 的最大值的加法标记，这是区间的 $t a g a m x$ 的历史最大值（历史指上一次 $P u s h d o w n$ 之后）；

$t a g b n m x$ —— 同上，这是区间的 $t a g a n m x$ 的历史最大值。

为什么 $t a g b m x$ 是 $t a g a m x$ 的历史最大值？

比如有一个变量 $v a l$ ，在下一次 $P u s h d o w n$ 前进行了两次加法操作：一次加 $5$ ，一次减 $2$ ，那么 $t a g a m x$ 的历史最大值应当为 $5$ ，此时 $v a l$ 才更有可能成为历史最大值。

然后我们来分析一下线段树的 $P u s h u p ， U p d a t e ， P u s h d o w n$ 三个操作。

首先是 $P u s h u p$ ，大力维护即可。

代码：

inline void Pushup(int now)
{
	suma[now] = suma[ls] + suma[rs];
	mxa[now] = max(mxa[ls], mxa[rs]);
	mxb[now] = max(mxb[ls], mxb[rs]);
	if(mxa[ls] == mxa[rs])
	{
		cntmx[now] = cntmx[ls] + cntmx[rs];
		cmxa[now] = max(cmxa[ls], cmxa[rs]);
		return;
	}
	if(mxa[ls] > mxa[rs])
	{
		cntmx[now] = cntmx[ls];
		cmxa[now] = max(cmxa[ls], mxa[rs]);
	}
	else
	{
		cntmx[now] = cntmx[rs];
		cmxa[now] = max(mxa[ls], cmxa[rs]);
	}
	return;
}

然后是 $U p d a t e$ ，它的函数框架应该是这样的：

inline void Update(int now, int l, int r, LL pamx, LL panmx, LL pbmx, LL pbnmx)

（ $p$ 前缀代指 $p l u s$ ，即需要加的数）

首先维护 $s u m a$ ，用 $p a m x$ 与 $c n t m x$ 配合维护即可。

其次，我们要维护 $m x b, t a g b m x, t a g b n m x$ 三个和 $B_i$ 有关的变量。

为什么呢？因为它们的维护与 $A_i$ 关系密切，而后面的操作会改变和 $A_i$ 有关的变量。

对于 $m x b$ ，我们把它和 $m x a + p b m x$ 取最大值，后者即为上文所提到的“历史最大值的可能值”。

对于 $t a g b m x$ ，我们把它和 $t a g a m x + p b m x$ 取最大值，原理同上。

同理，对于 $t a g b n m x$ ，我们把它和 $t a g a n m x + p b n m x$ 取最大值即可。

然后和 $A_i$ 有关的变量维护起来就没那么麻烦了，直接加即可，注意判断 $c m x a$ 的有无。

代码：

inline void Update(int now, int l, int r, LL pamx, LL panmx, LL pbmx, LL pbnmx)
{
	suma[now] += pamx * cntmx[now] + panmx * (r - l + 1 - cntmx[now]);
	mxb[now] = max(mxb[now], mxa[now] + pbmx);
	tagbmx[now] = max(tagbmx[now], tagamx[now] + pbmx);
	tagbnmx[now] = max(tagbnmx[now], taganmx[now] + pbnmx);
	mxa[now] += pamx, tagamx[now] += pamx, taganmx[now] += panmx;
	if(cmxa[now] != -INF) cmxa[now] += panmx;
	return;
}

写出了 $U p d a t e$ ，其实 $P u s h d o w n$ 也很好写了。

只要你真正理解了上述变量的含义，相信你看懂甚至独立写出下述代码都会易如反掌。

（注意左右儿子的 $m x a$ 最大值要保存起来）

inline void Pushdown(int now, int l, int r)
{
	int mxn = max(mxa[ls], mxa[rs]);
	if(mxa[ls] == mxn) Update(ls, l, mid, tagamx[now], taganmx[now], tagbmx[now], tagbnmx[now]);
	else Update(ls, l, mid, taganmx[now], taganmx[now], tagbnmx[now], tagbnmx[now]);
	if(mxa[rs] == mxn) Update(rs, mid + 1, r, tagamx[now], taganmx[now], tagbmx[now], tagbnmx[now]);
	else Update(rs, mid + 1, r, taganmx[now], taganmx[now], tagbnmx[now], tagbnmx[now]);
	return tagamx[now] = taganmx[now] = tagbmx[now] = tagbnmx[now] = 0LL, void();
}

接下来我们分析一下每个操作。

首先是操作 $1$ 。

这是线段树的基本操作，可以直接做。

在 $U p d a t e$ 函数中，我们对所有量一视同仁，加法标记（指函数参数）全部赋为 $k$ 。

代码：

inline void Modify_Plus(int now, int l, int r, int L, int R, LL k)
{
	if(L <= l && r <= R) return Update(now, l, r, k, k, k, k);
	Pushdown(now, l, r);
	if(L <= mid) Modify_Plus(ls, l, mid, L, R, k);
	if(R > mid) Modify_Plus(rs, mid + 1, r, L, R, k);
	return Pushup(now);
}

接着分析一下操作 $2$ 。

我们对 $v$ 分类讨论：（以下区间指线段树递归时遍历到的区间）

如果 $\ge mxa$ ，那么该操作不会有任何影响，直接跳过该区间即可；
如果 $c m x a < v < m x a$ ，那么该操作只会改变最大值，不会改变 $c n t m x$ ；
如果 $\le cmxa$ ，那么我们继续递归下去（线段树的叶子节点不会出现这种情况）。

对于最大值，加法标记即为 $k - m x a$ （减去 $m x a$ 加上 $k$ ，也就是把 $m x a$ 赋为 $k$ ）；对于非最大值，这样的修改不会有贡献，即加法标记为 $0$ 。

代码：

inline void Modify_Minimize(int now, int l, int r, int L, int R, LL k)
{
	if(k >= mxa[now]) return;
	if(L <= l && r <= R && k > cmxa[now]) return Update(now, l, r, k - mxa[now], 0, k - mxa[now], 0);
	Pushdown(now, l, r);
	if(L <= mid) Modify_Minimize(ls, l, mid, L, R, k);
	if(R > mid) Modify_Minimize(rs, mid + 1, r, L, R, k);
	return Pushup(now);
}

操作 $3, 4, 5$ 实际上是同普通的线段树完全一样的套路。

代码：

inline LL Query_Sum(int now, int l, int r, int L, int R)
{
	if(L <= l && r <= R) return suma[now];
	Pushdown(now, l, r);
	LL res = 0LL;
	if(L <= mid) res += Query_Sum(ls, l, mid, L, R);
	if(R > mid) res += Query_Sum(rs, mid + 1, r, L, R);
	return res;
}

inline LL Query_Maximum_A(int now, int l, int r, int L, int R)
{
	if(L <= l && r <= R) return mxa[now];
	Pushdown(now, l, r);
	LL res = -INF;
	if(L <= mid) res = max(res, Query_Maximum_A(ls, l, mid, L, R));
	if(R > mid) res = max(res, Query_Maximum_A(rs, mid + 1, r, L, R));
	return res;
}

inline LL Query_Maximum_B(int now, int l, int r, int L, int R)
{
	if(L <= l && r <= R) return mxb[now];
	Pushdown(now, l, r);
	LL res = -INF;
	if(L <= mid) res = max(res, Query_Maximum_B(ls, l, mid, L, R));
	if(R > mid) res = max(res, Query_Maximum_B(rs, mid + 1, r, L, R));
	return res;
}

当然还有 $B u i l d$ 函数，放总代码里啦。

总代码：

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cassert>
#include<algorithm>

#define MAXN 500005

using LL = long long;
using namespace std;

int n, m;
const LL INF = 0x3F3F3F3F3F3F3F3F;

namespace Segment_Tree_Beats
{
	#define ls (now << 1)
	#define rs (now << 1 | 1)
	#define mid ((l + r) >> 1)
	
	int cntmx[MAXN << 2];
	LL suma[MAXN << 2], mxa[MAXN << 2], cmxa[MAXN << 2], mxb[MAXN << 2], tagamx[MAXN << 2], taganmx[MAXN << 2], tagbmx[MAXN << 2], tagbnmx[MAXN << 2];

	inline void Pushup(int now)
	{
		suma[now] = suma[ls] + suma[rs];
		mxa[now] = max(mxa[ls], mxa[rs]);
		mxb[now] = max(mxb[ls], mxb[rs]);
		if(mxa[ls] == mxa[rs])
		{
			cntmx[now] = cntmx[ls] + cntmx[rs];
			cmxa[now] = max(cmxa[ls], cmxa[rs]);
			return;
		}
		if(mxa[ls] > mxa[rs])
		{
			cntmx[now] = cntmx[ls];
			cmxa[now] = max(cmxa[ls], mxa[rs]);
		}
		else
		{
			cntmx[now] = cntmx[rs];
			cmxa[now] = max(mxa[ls], cmxa[rs]);
		}
		return;
	}

	inline void Update(int now, int l, int r, LL pamx, LL panmx, LL pbmx, LL pbnmx)
	{
		suma[now] += pamx * cntmx[now] + panmx * (r - l + 1 - cntmx[now]);
		mxb[now] = max(mxb[now], mxa[now] + pbmx);
		tagbmx[now] = max(tagbmx[now], tagamx[now] + pbmx);
		tagbnmx[now] = max(tagbnmx[now], taganmx[now] + pbnmx);
		mxa[now] += pamx, tagamx[now] += pamx, taganmx[now] += panmx;
		if(cmxa[now] != -INF) cmxa[now] += panmx;
		return;
	}

	inline void Pushdown(int now, int l, int r)
	{
		int mxn = max(mxa[ls], mxa[rs]);
		if(mxa[ls] == mxn) Update(ls, l, mid, tagamx[now], taganmx[now], tagbmx[now], tagbnmx[now]);
		else Update(ls, l, mid, taganmx[now], taganmx[now], tagbnmx[now], tagbnmx[now]);
		if(mxa[rs] == mxn) Update(rs, mid + 1, r, tagamx[now], taganmx[now], tagbmx[now], tagbnmx[now]);
		else Update(rs, mid + 1, r, taganmx[now], taganmx[now], tagbnmx[now], tagbnmx[now]);
		return tagamx[now] = taganmx[now] = tagbmx[now] = tagbnmx[now] = 0LL, void();
	}

	inline void Build(int now, int l, int r)
	{
		if(l == r)
		{
			LL k; scanf("%lld", &k);
			return suma[now] = mxa[now] = mxb[now] = k, cntmx[now] = 1, cmxa[now] = -INF, tagamx[now] = taganmx[now] = tagbmx[now] = tagbnmx[now] = 0LL, void();
		}
		return Build(ls, l, mid), Build(rs, mid + 1, r), Pushup(now);
	}

	inline void Modify_Plus(int now, int l, int r, int L, int R, LL k)
	{
		if(L <= l && r <= R) return Update(now, l, r, k, k, k, k);
		Pushdown(now, l, r);
		if(L <= mid) Modify_Plus(ls, l, mid, L, R, k);
		if(R > mid) Modify_Plus(rs, mid + 1, r, L, R, k);
		return Pushup(now);
	}

	inline void Modify_Minimize(int now, int l, int r, int L, int R, LL k)
	{
		if(k >= mxa[now]) return;
		if(L <= l && r <= R && k > cmxa[now]) return Update(now, l, r, k - mxa[now], 0, k - mxa[now], 0);
		Pushdown(now, l, r);
		if(L <= mid) Modify_Minimize(ls, l, mid, L, R, k);
		if(R > mid) Modify_Minimize(rs, mid + 1, r, L, R, k);
		return Pushup(now);
	}

	inline LL Query_Sum(int now, int l, int r, int L, int R)
	{
		if(L <= l && r <= R) return suma[now];
		Pushdown(now, l, r);
		LL res = 0LL;
		if(L <= mid) res += Query_Sum(ls, l, mid, L, R);
		if(R > mid) res += Query_Sum(rs, mid + 1, r, L, R);
		return res;
	}

	inline LL Query_Maximum_A(int now, int l, int r, int L, int R)
	{
		if(L <= l && r <= R) return mxa[now];
		Pushdown(now, l, r);
		LL res = -INF;
		if(L <= mid) res = max(res, Query_Maximum_A(ls, l, mid, L, R));
		if(R > mid) res = max(res, Query_Maximum_A(rs, mid + 1, r, L, R));
		return res;
	}

	inline LL Query_Maximum_B(int now, int l, int r, int L, int R)
	{
		if(L <= l && r <= R) return mxb[now];
		Pushdown(now, l, r);
		LL res = -INF;
		if(L <= mid) res = max(res, Query_Maximum_B(ls, l, mid, L, R));
		if(R > mid) res = max(res, Query_Maximum_B(rs, mid + 1, r, L, R));
		return res;
	}
	#undef ls
	#undef rs
	#undef mid
}

namespace stb = Segment_Tree_Beats;

int main()
{
	#ifdef FILE
		freopen("Input.in", "r", stdin);
	#endif
	scanf("%d%d", &n, &m);
	stb :: Build(1, 1, n);
	while(m--)
	{
		int opt, l, r; scanf("%d%d%d", &opt, &l, &r);
		if(opt == 1)
		{
			LL k; scanf("%lld", &k);
			stb :: Modify_Plus(1, 1, n, l, r, k);
			continue;
		}
		if(opt == 2)
		{
			LL k; scanf("%lld", &k);
			stb :: Modify_Minimize(1, 1, n, l, r, k);
			continue;
		}
		if(opt == 3) printf("%lld\n", stb :: Query_Sum(1, 1, n, l, r));
		if(opt == 4) printf("%lld\n", stb :: Query_Maximum_A(1, 1, n, l, r));
		if(opt == 5) printf("%lld\n", stb :: Query_Maximum_B(1, 1, n, l, r));
	}
	return 0;
}