CF1144G & CF1693D & CF1647F

CF1144G：

给定一个长度为 $n$ 的序列 $A$。
问能否把它拆成一个严格递增序列和一个严格递减序列（可以为空），如果有解则输出方案。
$n\le 2\times 10^5$。

设 $f_{i,0}$ 表示把序列的前 $i$ 个数拆成递增序列和一个递减序列（可以为空），并且 $A_i$ 属于递增序列时，递减序列结尾可能的最大值。$f_{i,1}$ 表示 $A_i$ 属于递减序列时，递增序列结尾可能的最小值。
转移有四种：

• $A_{i-1},A_i$ 都属于递增序列，则若 $A_{i-1}\lt A_i$，则用 $f_{i-1,0}$ 更新 $f_{i,0}$。
• $A_{i-1},A_i$ 都属于递增序列，情况类似。
• $A_{i-1}$ 属于递减序列，$A_i$ 属于递增序列，则若 $f_{i-1,1}\lt A_i$，用 $A_{i-1}$ 更新 $f_{i,0}$。
• $A_{i-1}$ 属于递增序列，$A_i$ 属于递减序列，情况类似。

为了输出方案，记 $g_{i,0}$ 表示在最优方案中，$A_{i-1}$ 属于哪个序列，$g_{i,1}$ 同理。
实现时可以把 $f,g$ 用 pair<int,int> 压在一起。

Code：

#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
typedef pair <int, int> pii;
const int N = 200005, inf = 0x3f3f3f3f;
int n;
int a[N];
int ans[N];
pii f[N][2];

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
	f[1][0].fi = inf, f[1][1].fi = -1;
	for (int i = 2; i <= n; ++i) {
		f[i][0].fi = -1, f[i][1].fi = inf;
		if (a[i - 1] < a[i]) f[i][0] = pii(f[i - 1][0].fi, 0);
		if (a[i - 1] > a[i]) f[i][1] = pii(f[i - 1][1].fi, 1);
		if (f[i - 1][1].fi < a[i]) f[i][0] = max(f[i][0], pii(a[i - 1], 1));
		if (f[i - 1][0].fi > a[i]) f[i][1] = min(f[i][1], pii(a[i - 1], 0));
	}
	if (~f[n][0].fi || f[n][1].fi < inf) {
		printf("YES\n");
		ans[n] = ~f[n][0].fi ? 0 : 1;
		for (int i = n; i > 1; --i) ans[i - 1] = f[i][ans[i]].se;
		for (int i = 1; i <= n; ++i) printf("%d ", ans[i]);
	}
	else printf("NO");
	return 0;
}

CF1693D：

给出一个排列，求出这个排列中有多少个子区间，满足能够被划分为一个严格递增序列和一个严格递减序列（可以为空）。

很神奇的性质题啊
首先状态沿用上面一题的
首先有个很暴力的想法，从小到大枚举左端点，尝试扩展右端点，这样做是 $\mathcal O(n^2)$ 的。
换种思路，我们从大到小枚举左端点。
考虑在 DP 过程中，如果一个点的 DP 值均没变，那么直接继承上一个位置能扩展到的最远点。否则如果拆不下去了，就更新最远点。
这看起来是个常数优化，但是这把 $\mathcal O(n^2)$ 降到了 $\mathcal O(n)$ ！！！神奇吧
证明：
在 $i$ 之前找到最大的一个 $j$，满足 $A_j\gt A_{j+1}$，那么 $A_j,A_{j+1}$ 显然不能同时在递增序列中，$f_{i,0}$ 的取值必然为 $A_j,A_{j+1},-\infty$ 之一，若不存在这样的 $j$，则 $f_{i,0}=\infty$。
也就是说，$f_{i,0}$ 的取值只有 $4$ 种情况。同理 $f_{i,1}$ 的取值也只有 $4$ 种情况。
每次更新至少有一个值改变，至多 $8$ 个取值，所以时间复杂度是 $\mathcal O(n)$ 的。

Code：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200005, inf = 0x3f3f3f3f;
int n;
int a[N], f[N][2];
int lst;
ll ans;

void work(int l) {
	f[l][0] = inf, f[l][1] = -inf;
	for (int i = l + 1; i <= n; ++i) {
		int w0 = -inf, w1 = inf;
		if (a[i] > a[i - 1]) w0 = max(w0, f[i - 1][0]);
		if (a[i] > f[i - 1][1]) w0 = max(w0, a[i - 1]);
		if (a[i] < a[i - 1]) w1 = min(w1, f[i - 1][1]);
		if (a[i] < f[i - 1][0]) w1 = min(w1, a[i - 1]);
		if (f[i][1] == w1 && f[i][0] == w0) break;
		else f[i][1] = w1, f[i][0] = w0;
		if (f[i][0] == -inf && f[i][1] == inf) { lst = i - 1; break; }
	}
	ans += lst - l + 1;
}

int main() {
	scanf("%d", &n), lst = n;
	for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
	for (int i = n; i; --i) work(i);
	printf("%lld", ans);
	return 0;
}

CF1647F：

现在给出一个序列，把它恰好分成两个子序列，使得每一个子序列都是单峰的。
求两个单峰子序列的峰的组合，有多少种情况。（保证给出的序列元素互不相同）

首先状态还是沿用上面的
发现必然有一个峰值是全局最大值（位置设为 $x$），所以最终答案小于 $n$。
我们约定另一个峰值在最大值之右（位置设为 $y$）（之左的情况 reverse 序列再做一遍）。那我们要做的就是：

1. 将 $[1,x]$ 分解成两个递增序列，让不包含 $x$ 位置的序列右端值最小（贪心）。
2. 将 $[y,n]$ 分解成两个递减序列，同上方贪心让序列左端值最小。
3. 将 $[x,y]$ 分解成（一个递减、一个递增）两个序列，必须保证 $a_x$ 在递减序列里，$a_y$ 在递增序列里。
   

$1,2$ 就用普通的线性 DP 解决，$2$ 的 DP 数组要计算到 $x+1$，DP 数组都要保存下来。
$3$ 接上 $1$ 的末尾，从 $x$ 开始向右 DP，保存 DP 数组。
然后枚举 $y\in[x+1,n]$，用 $2,3$ 的 DP 数组判断能否接上，统计答案。

Code：

#include <bits/stdc++.h>
using namespace std;
const int N = 500005, inf = 0x3f3f3f3f;
int n, a[N];
int g[N], h[N], f[N][2];
int p;
int ans;

void chkmax(int &a, int b) { if (a < b) a = b; }

void chkmin(int &a, int b) { if (a > b) a = b; }

void solve() {
	g[1] = 0;
	for (int i = 2; i <= p; ++i) {
		g[i] = inf;
		if (a[i - 1] < a[i]) chkmin(g[i], g[i - 1]);
		if (g[i - 1] < a[i]) chkmin(g[i], a[i - 1]);
	}
	if (g[p] == inf) return;
	int val = g[p];
	h[n] = 0;
	for (int i = n - 1; i > p; --i) {
		h[i] = inf;
		if (a[i + 1] < a[i]) chkmin(h[i], h[i + 1]);
		if (h[i + 1] < a[i]) chkmin(h[i], a[i + 1]);
	}
	f[p][0] = 0, f[p][1] = val;
	for (int i = p + 1; i <= n; ++i) {
		f[i][0] = 0, f[i][1] = inf;
		if (a[i - 1] < a[i]) chkmax(f[i][0], f[i - 1][0]);
		if (a[i - 1] > a[i]) chkmin(f[i][1], f[i - 1][1]);
		if (f[i - 1][1] < a[i]) chkmax(f[i][0], a[i - 1]);
		if (f[i - 1][0] > a[i]) chkmin(f[i][1], a[i - 1]);
	}
	for (int i = p + 1; i <= n; ++i) if (f[i][0] > h[i]) ++ans;
}

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
	for (int i = 1; i <= n; ++i) if (a[p] < a[i]) p = i;
	solve();
	p = n + 1 - p, reverse(a + 1, a + n + 1);
	solve();
	printf("%d", ans);
	return 0;
}