CF115E Linear Kingdom Races

做过的原题不会 该反思了。

---

做法一

考虑 $f_i$ 表示考虑前 $i$ 条路能获得的最大价值

那么如果不修这条路 就有 $f_i=f_{i-1}$

如果修了这条路 考虑把含 $i$ 的一段前缀即 $[j,i]$ 这段的路都修好
设 $cos{t}_{j,i}$ 表示把 $[j,i]$ 区间的路都修好需要的花费
$va{l}_{j,i}$ 表示把 $[j,i]$ 区间的路都修好能获得的价值
那么就有 $f_i=\underset{1\le j<i}{max}(f_{j-1}-cos{t}_{j,i}+va{l}_{j,i})$

考虑线段树优化 DP 首先我们把所有路按右端点排序
然后线段树的第 $j$ 个位置表示对于当前的 $i$ 来说 $f_{j-1}-cos{t}_{j,i}+va{l}_{j,i}$ 的值

那么我们考虑右移 $i$ 的对于这棵线段树上每个点的值的影响
首先有 $cos{t}_{j,i-1}\to cos{t}_{j,i}$ 多出了 $i$ 这个点的花费
其次有 $va{l}_{j,i-1}\to va{l}_{j,i}$ 即对于所有右端点在 $i$ 的比赛 设它的左端点是 $l$ 那么对于所有 $j\le l$ 都要加上这条路的收益
最后更新 $f_i$ 并把它插入 $i$ 位置
这样转移直接查区间 $max$ 即可 总复杂度 $\text{O}(n\log n)$

#include <bits/stdc++.h>
#define ls (k << 1)
#define rs (k << 1 | 1)
#define mid (l + r >> 1)
#define ll long long
#define int long long
using namespace std;

namespace steven24 {

const int N = 2e5 + 0721;
const ll inf = 0x7ffffffffffffff;
int v[N];
ll f[N];
int n, m;

struct node {
	int l, r, p;
	friend bool operator<(node x, node y) {
		return x.r < y.r;
	}
} race[N];

struct tree {
	ll tr[N << 2], lazy[N << 2];
	
	inline void pushup(int k) {
		tr[k] = max(tr[ls], tr[rs]);
	}
	
	void add(int k, int val) {
		tr[k] += val;
		lazy[k] += val;
	}
	
	void pushdown(int k) {
		add(ls, lazy[k]);
		add(rs, lazy[k]);
		lazy[k] = 0;
	}
	
	void modify(int k, int l, int r, int val, int u, int v) {
		if (u <= l && v >= r) {
			add(k, val);
			return;
		}
		if (lazy[k]) pushdown(k);
		if (u <= mid) modify(ls, l, mid, val, u, v);
		if (v > mid) modify(rs, mid + 1, r, val, u, v);
		pushup(k);
	}
	
	void give(int k, int l, int r, int val, int loc) {
		if (l == r) {
			tr[k] = val;
			return;
		}
		if (lazy[k]) pushdown(k);
		if (loc <= mid) give(ls, l, mid, val, loc);
		else give(rs, mid + 1, r, val, loc);
		pushup(k);
	}
	
	ll query(int k, int l, int r, int u, int v) {
		if (u <= l && v >= r) {
			return tr[k];
		}
		if (lazy[k]) pushdown(k);
		ll ret = -inf;
		if (u <= mid) ret = max(ret, query(ls, l, mid, u, v));
		if (v > mid) ret = max(ret, query(rs, mid + 1, r, u, v));
		pushup(k);
		return ret;
	}
} seg;

void dp() {
	int prs = 1;
	for (int i = 1; i <= n; ++i) {
		seg.modify(1, 1, n, -v[i], 1, i);
		while (prs <= m && race[prs].r == i) {
			seg.modify(1, 1, n, race[prs].p, 1, race[prs].l);
			++prs;
		}
		f[i] = max(f[i - 1], seg.query(1, 1, n, 1, i));
		seg.give(1, 0, n, f[i], i + 1);
	}
}

void main() {
	
	scanf("%lld%lld", &n, &m);
	for (int i = 1; i <= n; ++i) scanf("%lld", &v[i]);
	for (int i = 1; i <= m; ++i) scanf("%lld%lld%lld", &race[i].l, &race[i].r, &race[i].p);
	sort(race + 1, race + 1 + m);
	
	dp();
	
	printf("%lld", f[n]);
}
}

signed main() {
	steven24::main();
	return 0;
}
/*
7 4
3 2 3 2 1 2 3
1 2 5
2 3 5
3 5 3
7 7 5
*/

---

做法二

来自 @KHIN

考虑 $f_{i,j}$ 表示我当前右端点在 $i$ 强制把 $[j,i]$ 这段区间都修好的最大收益
特别地 定义 $f_{i,i+1}$ 表示考虑前 $i$ 个位置的最大收益

考虑转移 枚举 $j\le i$ 有 $f_{i,j}=f_{i-1,j}-c_i+\sum va{l}_k$
其中 $k$ 表示所有右端点为 $i$ 左端点 $\ge j$ 的比赛
对于 $f_{i,i+1}$ 有 $f_{i,i+1}=max(\underset{1\le j\le i}{max}{f}_{i,j},f_{i-1,i})$ 代表修/不修 $i$ 这个点

考虑线段树优化 DP 考虑 $i-1\to i$ 的过程
首先大家都要减去 $c_i$
然后考虑每个右端点在 $i$ 的比赛 所有 $[l,i]$ 的点都要加上 $va{l}_k$

所以我们转移的时候先记录 $f_{i-1,i}$
然后更新 $f$ 数组
最后把 $f_{i,i+1}$ 插入

即先转移有限制的 再转移无限制的