CF1648D 题解

CF1648D 题解

在这里分享两种做法，分别是 $O(n\log^2n)$ 的 cdq 分治，和 $O(n\log n)$ 的线段树，

由于笔者学艺不精，故如有错误或笔误之处欢迎提出，笔者将不胜感激。

题意：

给一条 $3$ 行 $n$ 列的带权（可以为负）网格，最初时第二行的所有格子是黑色，其它格子是白色。

你有一些三元组 $(L_p,R_p,k_p)$，代表可以花费 $k_p$ 的代价把第二行在区间 $[L_p,R_p]$ 内的格子染黑。

你需要找到一条从 $(1,1)$ 到 $(n,m)$ 的纯黑色路径，并最大化经过格子的权值和减去染色的代价。

做法：

设 $(i,j)$ 处格子的权为 $v_{i,j}$，我们记 $s_{x,y}=\sum\limits_{i=1}^yv_{x,i},a_l=s_{1,l}-s_{2,l-1},b_r=s_{3,n}-s_{3,r-1}+s_{2,r}$，则：

问题等价于求 $\max\limits_{1\le l\le r\le n}(a_l+b_r-cost(l,r))$，其中 $cost(l,r)$ 是将第二行中区间 $[l,r]$ 染黑的最小代价。

我们考虑如何计算 $cost$ 函数的值，这时可以考虑一个暴力的 DP，即：

初始值是：$\forall l\in[1,n],cost(l,l-1)=0$，即初始时第二行所有格子都不是黑色；

转移式为：$cost(l,i)=\min\limits_{\exists p\space:\space i,j\in[L_p,R_p],j\le i}(cost(l,j-1)-k_p)$，即用第 $p$ 个三元组拓宽已染黑的区间。

发现 $cost(l,r)$ 在转移时其 $l$ 不变，且转移仅与 $r$ 有关，那我们记 $f(r)=\max\limits_{l\le r}(a_l-cost(l,r))$，

则此时 $f$ 函数也能用 DP 的方式计算，即：$f(r)=\max\limits_{\exists p\space:\space L_p\le l\le r\le R_p}(f(l-1)-k_p)$。

这个式子是容易得到的，将 $f$ 函数的定义式里的 $cost$ 函数表示为其转移式就行。

那么最后的答案就等于 $\max\limits_{r=1}^n(b_r+f(r))$，我们也就得到了一个 $O(n^2)$ 的做法，但其实可以继续优化。

我们可以用 cdq 分治为 $f$ 函数的计算加速，具体来说，我们对当前分治区间 $[l,r]$ 及区间中点 $mid$，

我们先递归处理区间 $[l,mid]$ 的 $f$ 值，若三元组 $(L_p,R_p,k_p)$ 满足 $L_p\le mid<R_p$，

则对 $\forall \max(l,L_p)\le i\le mid<j\le\min(R_p,r)$，我们都可以花费 $k_p$ 的代价从 $f(i-1)$ 转移到 $f(j)$。

那么，我们可以将所有满足上面条件的转移 $i-1\rightarrow j$ 拆成三步，即：

先从 $f(i-1)$ 转移到 $f(L_p)$，再从 $f(L_p)$ 转移到 $f(R_p)$，最后从 $f(R_p)$ 转移到 $f(j)$。

容易发现，如果你用做后缀 $\max$ 的方式去维护第一步和第三步，并暴力的维护第二步，

那么复杂度递推式就是：$T(l,r)=T(l,mid)+T(mid+1,r)+O(r-l)+O(num(l,r))$，

其中 $num(l,r)$ 为对 $[l,r]$ 能产生影响的三元组个数，故 $T(l,r)=O(n\log^2n)$，

原因是三元组最多只会影响到 $O(\log n)$ 个分治区间的转移，

这个可以用线段树区间操作的复杂度来证明，即可以将任意 $[l,r]$ 拆成 $O(\log n)$ 个线段树上的区间，

而对分治区间 $[l,r]$，若 $\exists p,q$ 作为两个三元组的编号，满足 $[l,r]\subseteq[L_p,R_p],[l,r]\subseteq[L_q,R_q]$，

则 $p$ 和 $q$ 中 $k$ 值较大的那个一定是无用的。

以上只是介绍了一种对本题中 cdq 分治的复杂度的一种理解方式，而并不是更严谨的证明，

更严谨的证明可能还需要一些讨论，但由于笔者写的不是这种做法，故当时并没有做严谨的证明，

但相信强大的读者们一定能够自行完成这个证明。

事实上，上面的 DP 式还有一种优化方式，即减少无用转移以优化转移复杂度。

为了方便说明我们是如何优化转移的，在此我们先说明一些定义。

我们首先定义 “ $f(i)$ 能转移一次后到 $f(j)$ ” 为，$f(j)$ 最终的最优解可以由 $f(i)$ 的转移而取到，

即 $f(i)$ 可以作为 $f(j)$ 在 DP 的最优转移的 DAG 中的前驱。

为了使叙述更便捷，我们用 $f(i)\rightarrow f(j)$ 来代替 “ $f(i)$ 能转移一次后到 $f(j)$ ” 。

自然的，对于 $\forall m>1$，我们可以定义 “ $f(i)$ 能转移 $m$ 次后到 $f(j)$ ” 为，存在序列 $p[1\cdots m]$，满足：

$f(i)\rightarrow f(s_1),\forall q\in [1,m-1], f(p_q)\rightarrow f(p_{q+1}),f(p_m)\rightarrow f(j)$ 这些条件全部成立。

那么，考虑这样的序列可能会有很多种，相应的，我们也就做了很多次无用转移，

因为我们只需要所有合法序列中的一个就可以从 $i$ 转移到 $j$。

那么，我们可以考虑适当并合理地减少转移量，使对 $\forall i,j,m(i<j)$，合法的序列 $p[1\cdots m]$ 唯一。

这等价于给出一些限制并按照限制来调整 $p$ 序列，最后再给出一种新的转移方式，

使得这个转移方式的实际效果与调整后的 $p$ 序列是一致的，且这个新转移的复杂度更低或可以优化。

那我们先考虑如何合理的调整 $p$ 序列。

一个想法是，我们在保证序列合法的前提下，将 $p$ 中每一个位置调整地尽量靠左，

以达到类似去重的目的。注意到为什么这里的 ” 尽量靠左 “ 的限制没有给出一个调整的先后顺序，

是因为：如果将位置 $p_t$ 调整成 $p'_t$ 后 $p$ 序列仍合法，

则 $p_t$ 所能转移到的位置集，必须与 $p'_t$ 所能转移到的位置集一致，否则一定能构造出不合法的例子，

故此时确定调整顺序是不必要的，且按任意一种调整顺序去调整到尽量靠左，最后结果都是一致的。

一种更直观的的证明，是考虑原序列 $p$ 一定有一个对应的有序三元组集合，

这个集合的每个元素，分别为 $i,p_1,p_2,\cdots,p_m,j$ 这些位置中的每对相邻位置，提供了转移的条件，

故这个集合的大小是 $m+1$，而 $p_t$ 可以调整到的合法位置就是 $[L_t,R_t]\cap[L_{t+1}-1,R_{t+1}]$，

再进一步发现，此时一定有 $[L_t,R_t]\cap[L_{t+1}-1,R_{t+1}]=[L_{t+1}-1,R_t]$，原因是：

这些区间显然不会有包含或不交的情况，而因为 DP 转移时下标单增，

故这个有序三元组集一定满足：$\forall t\in[1,m],L_t<L_{t+1},R_t<R_{t+1}$，即可证明上面结论。

而由于我们想让每个元素尽量靠左，故此时对 $\forall t\in[1,m]$，$p_t$ 就会被调整到 $L_{t+1}-1$ 位置。

那么我们考虑应该如何转移，才能使转移的实际效果，与按照上面方式来调整后得到的序列 $p$ 一致。

发现新的转移方式等价于，每次转移到的新点，都是某个三元组对应区间 $[L_q,R_q]$ 的左端点减一，

而这个三元组 $(L_q,R_q,k_q)$ 也一定会被下一次转移所依赖，即下一次转移靠的就是这个三元组。

也就是说，我们除了在第一次转移时会从任意位置出发，

以后的每次转移的起点都是某个三元组对应区间 $[L_p,R_p]$ 的左端点，终点是这个区间内的所有点。

这时我们需要支持区间与某数取 $\max$ 和单点查询的数据结构，而线段树已经足以支持这一点了，

但实际上我们没必要写区间取 $\max$ 数据结构 ，而是考虑将第二行整体翻转后，转移的形式。

发现此时转移等价于：除了最后一次转移的终点可以是任意点，

其余每次转移的起点是某个三元组对应区间 $[L_q,R_q]$ 内所有点，终点是 $R_q+1$，

原因也是好理解的，即我们将第二行翻转后，三元组对应区间的左端点减一，就变成了右端点加一。

那么，除最后一步以外的转移，我们只需要区间查询 $\max$ 值，单点修改的数据结构就能快速维护。

而最后一步，我们可以把统计的答案稍作修改，即：$\max\limits_{\exists p\space:\space1\le L_p\le l\le r\le R_p\le n}(f(l)+b_r-k_p)$，

如果我们统计的是这个答案，那么我们对最后一步的转移，就也可以与其它转移一样了，

因为此时，最后一步只转移到了倒数第二个用来染色的三元组对应区间 $[L_m,R_m]$ 的右端点加一，

而此时 $R_p+1$ 一定在最后一个用来染色的三元组对应区间 $[L_{m+1},R_{m+1}]$ 内，

故上面的答案统计一定是正确的，而快速维护答案的方法，我们也只需要一棵线段树即可，

具体来说，我们算好 $f$ 函数后，枚举三元组 $p$，则你需要查询 $\max\limits_{L_p\le l\le r\le R_p}(f(l)+b_r)$，

而这个式子放在线段树上是具有结合律的信息，我们可以用类似于维护区间最大子段和的方法做到。

这样的时间复杂度就是 $O(n\log n)$ 的，下面放个代码，代码里的实现可能与题解中所讲略有不同。

#include <bits/stdc++.h>

#define fi first
#define se second
#define vi vector
#define db double
#define mp make_pair
#define pb push_back
#define LL long long
#define emp emplace_back
#define pii pair < int , int >
#define SZ(x) ((int)(x.size()))
#define all(x) x.begin(), x.end()
#define ckmax(a, b) ((a) = max((a), (b)))
#define ckmin(a, b) ((a) = min((a), (b)))
#define rep(i, a, b) for (int i = (a); i <= (b); i++)
#define per(i, a, b) for (int i = (a); i >= (b); i--)
#define edg(i, v, u) for (int i = head[u], v = e[i].to; i; i = e[i].nxt, v = e[i].to)
#define rt 1, 1, n
#define mid ((l + r) >> 1)
#define lsn p << 1, l, mid
#define rsn p << 1 | 1, mid + 1, r
using namespace std;
int read (char ch = 0, int x = 0, int f = 1) { 
	// 快读就不放了
}
void write (int x) { 
	// 快输也不放了
}

const int N (5e5 + 5);
const LL INF (4e18 + 5);

int n, q;
LL x[4][N];
LL s[4][N];
LL s2[2][N];
LL a[N];
LL b[N];

struct Node {
	int l, r; LL k;
} seg[N];
struct Data {
	LL lmx, rmx, val;
};
bool cmp (Node u, Node v) {
	return u.r < v.r;
}
Data mrg (Data u, Data v) { //查询最后答案时，合并区间信息
	Data r;
	r.lmx = max (u.lmx, v.lmx);
	r.rmx = max (u.rmx, v.rmx);
	r.val = max ({u.val, v.val, u.lmx + v.rmx});
	return r;
}
struct SGTlft { // 用来维护转移的线段树
	LL t[N << 2];
	void push_up (int p) {
		t[p] = max (t[p << 1], t[p << 1 | 1]);
	}
	void build (int p, int l, int r) {
		t[p] = -INF;
		if (l == r) t[p] = s[1][l] - s2[0][l - 1];
		else build (lsn), build (rsn), push_up (p);
	}
	LL qmax (int p, int l, int r, int ql, int qr, LL ret = -INF) {
		if (ql <= l && qr >= r) return t[p];
		if (ql <= mid) ckmax (ret, qmax (lsn, ql, qr));
		if (qr > mid)  ckmax (ret, qmax (rsn, ql, qr));
		return ret;
	}
	void upd (int p, int l, int r, int pos, LL val) {
		if (l == r) return ckmax (t[p], val), void();
		if (pos <= mid) upd (lsn, pos, val);
		else upd (rsn, pos, val);
		push_up (p); 
	}
} t1;

struct SGTmax { //最后用来查询答案的线段树
	Data t[N << 2];
	void push_up (int p) {
		t[p] = mrg (t[p << 1], t[p << 1 | 1]);
	}
	void build (int p, int l, int r) {
		t[p] = {-INF, -INF, -INF};
		if (l == r) t[p] = {a[l], b[l], a[l] + b[l]};
		else build (lsn), build (rsn), push_up (p);
	}
	Data qry (int p, int l, int r, int ql, int qr, LL ret = -INF) {
		if (ql <= l && qr >= r) return t[p];
		Data lft = {-INF, -INF, -INF}, rht = {-INF, -INF, -INF};
		if (ql <= mid) lft = qry (lsn, ql, qr);
		if (qr > mid) rht = qry (rsn, ql, qr);
		return mrg (lft, rht);
	}
} t2;

int main() {
	LL res = -INF;
	n = read(), q = read();
	rep (i, 1, 3) rep (j, 1, n) x[i][j] = read();
	rep (i, 1, n) s[1][i] = s[1][i - 1] + x[1][i], 
				  s2[0][i] = s2[0][i - 1] + x[2][i];
	per (i, n, 1) s[3][i] = s[3][i + 1] + x[3][i],
				  s2[1][i] = s2[1][i + 1] + x[2][i];
	rep (i, 1, q) 
	  seg[i].l = read(), seg[i].r = read(), seg[i].k = read();
	sort (seg + 1, seg + q + 1, cmp), t1.build (rt);
	rep (i, 1, q) {
		int l = seg[i].l, r = seg[i].r; LL k = seg[i].k;
		LL val = t1.qmax (rt, l, r) - k; t1.upd (rt, r + 1, val);
	}
	rep (i, 1, n) a[i] = t1.qmax (rt, i, i), b[i] = s[3][i] - s2[1][i + 1];
	t2.build (rt);
	rep (i, 1, q) {
		int l = seg[i].l, r = seg[i].r; LL k = seg[i].k;
		ckmax (res, t2.qry (rt, l, r).val - k);
	}
	printf ("%lld\n", res + s2[0][n]);
	return 0;
}