[动态规划]CF1271D Portals

题目链接

首先有一个贪心结论需要发现，就是一个城堡晚守总比早守好。

为啥呢？如果一个城堡可以以后通过传送门再守，那你到时候可以再决定。如果到时候发现兵不够了，那可以一直预留一个兵给这个城堡。总之，所能做的决策是现在守的决策的超集。

那么对于每个城堡算出最后能到达它的城堡即可。每个城堡，能更新它的城堡有且只有一个。

然后考虑 dp 的转移。看到数据范围肯定是一个 \(\mathcal O(n^2)\) 的东西，那么设 \(dp_{i,j}\) 为前 \(i\) 个城堡（注意第 \(i\) 个城堡的决策已经做完）有 \(j\) 个兵，所能获得最大重要值。

对于一个城堡他有两个选项。要么不防御这个城堡所能防御的城堡，要么通过这个城堡去防御它所能防御的城堡。这个状态是正确的，就是因为我们在贪心后发现，每一个城堡只能从一座城堡防御。因此它所能防御的城堡一定是一个还没防御的状态。

列式子 \(dp_{i, j} = \max(dp_{i - 1, j - b_i}, dp_{i, j + 1} + c_{to})\)。其中 \(to\) 代表只能被 \(i\) 防御的城堡。

呃这题其实做完了，但是又没做完，因为代码还有两个重要的细节。

#include <bits/stdc++.h>
#define rep(i, a, b) for(register int i = a; i <= b; ++i)
#define rep_(i, a, b) for(register int i = a; i >= b; --i)
using namespace std;
constexpr int N = 5e3 + 5;
bool flag;
int ans, sum, n, m, u, v, a[N], b[N], c[N], from[N], dp[N][N];
vector<int> t[N];
int main() {
	cin >> n >> m >> sum;
	rep(i, 1, n) {
		cin >> a[i] >> b[i] >> c[i];
		from[i] = i;
	}
	while(m--) {
		cin >> u >> v;
		from[v] = max(from[v], u);
	}
	rep(i, 1, n) {
		t[from[i]].push_back(i);
	}
	rep(i, 1, n) {
		if(sum < a[i]) {
			flag = true;
			break;
		}
		sum += b[i];
		rep(j, a[i] + b[i], sum) { // Problem1
			dp[i][j] = dp[i - 1][j - b[i]];
		}	
		for(const register int to : t[i]) {
			rep(j, 0, sum - 1) {//Problem2
				dp[i][j] = max(dp[i][j + 1] + c[to], dp[i][j]);
			}
		}
	}
	if(flag) {
		cout << -1;
		return 0;
	}
	rep(i, 0, sum) {
		ans = max(ans, dp[n][i]);
	}
	cout << ans;
	return 0;
}

• Problem1

为啥下边界是 \(a_i + b_i\) 而不用保证 \(j\) 在之前是合法的呢？

比如取 \(\max(a_i + b_i, a_{i - 1} + b_{i - 1} + b_i\)) ?

这个问题我思考很久，这其实跟我们的状态设计有关。前面我强调过，\(dp_{i,j}\) 中的 \(j\) 是一个 \(i\) 决策已经做完了的状态。因此，有可能是在攻城堡的时候合法，然后攻城堡之后通过传送门守城堡时士兵不够了。

所以对于以前，即使是一个 \(j - b_i - b{i - 1} < a_{i - 1}\) 的状态，也并非非法，是有用的，是可以转移的。

• Problem2

为啥正序而非倒序？

这个是好解释的，和背包是一个道理。如果倒序的话 \(c_{to}\) 会被多次计算。