洛谷 P1220 关路灯（记忆化DP，区间DP）

题目大意：

有n个路灯，每个路灯都有各自的位置ai，以及功率bi，已知小明站在某个c路灯处，小明的步行速率是1m/s，问我们小明怎么关灯使得我们的电量消耗最少。

解题思路：

首先，我们发现小明关灯肯定是关掉一个区间的灯，毕竟不可能小明路过一个灯不去关它，这是毫无益处的，所以这里我们考虑转换为区间DP，所以可以有状态 [l][r]，其中l，r分别表示所在的路灯的编号，这个状态表示在[l][r]区间中的最少耗电量。为了能够转移出去，我们还需要考虑两种情况，小明站在l点或者小明站在r点，这时候就能得到我们的转移方程：

memo[l][r][1]=min(memo[l][r-1][0]+calc(),memo[l][r-1][1]+calc())

memo[l][r][0]=min(memo[l+1][r][0]+calc(),memo[l+1][r][1]+calc())

其中calc表示中间走过程的损耗。损耗等于时间乘以功率，时间相当于距离这个好算，功率的话利用前缀和可以O（1）算区间功率和，这个也没什么好说的。

在这里有一个问题是，边界在哪：

我们知道在做记忆化DP时，传入的参数有：ll,rr，其中ll，rr分别表示当前访问区间。

我们知道ll必须要小于等于c，所以当ll走到c的时候memo[l][r][0]即为一个无效的状态，可以设为INF

我们知道rr必须要大于等于c，所以当rr走到c的时候memo[l][r][1]即为一个无效的状态，可以设为INF

废话：这里我们再次看到了转为区间DP，可见这种做法非常重要！可以多往区间这里靠！其它的可能可以转化为区间覆盖问题啊等等！总之区间有很多有意思的问题！

另外这里也让我们看到了DP转移中的边界条件！

最后，我们需要注意为什么这里我们设了一些状态为INF，因为我们认为从这些状态转移开来是不合理的。这种设置状态的思想要学会！

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 60;
int p[MAXN], l[MAXN], r[MAXN];
pair<int, int> memo[MAXN][MAXN];
#define OPEN 0
int c;
const int INF = 1e9 + 10;
int calc(int pl, int pr, int la, int ra) {
	return (p[pr] - p[pl])*(l[la + 1] + r[ra + 1]);
}

pair<int, int> dfs(int ll, int rr) {

	if (memo[ll][rr].first != -1) {
		assert(memo[ll][rr].second != -1);
		return memo[ll][rr];
	}
	
	int fir, sec;
	if(rr!=c)
	sec = min(dfs(ll, rr - 1).second + calc(rr - 1, rr, ll - 1, rr), dfs(ll, rr - 1).first + calc(ll, rr, ll - 1, rr));
	else sec=INF;
	
	if(ll!=c)
	fir = min(dfs(ll + 1, rr).first + calc(ll, ll + 1, ll, rr + 1), dfs(ll + 1, rr).second + calc(ll, rr, ll, rr + 1));
	else fir=INF;
	memo[ll][rr].first = fir;
	memo[ll][rr].second = sec;
	return memo[ll][rr];

}
int main() {
#if OPEN
	freopen("in.txt", "r", stdin);
#endif
	int n;cin >> n >> c;
	int power[MAXN];
	int minpos = INF;
	int maxpos = -INF;
	c -= 1;
	for (int i = 0;i<n;i++) {
		cin >> p[i] >> power[i];
		minpos = min(minpos, p[i]);
		maxpos = max(maxpos, p[i]);
	}
	if (n == 1) {
		cout << 0 << endl;
		return 0;
	}
	memset(l, 0, sizeof(l));
	memset(r, 0, sizeof(r));

	for (int i = 0;i<MAXN;i++)
		for (int j = 0;j<MAXN;j++)
			memo[i][j].first = memo[i][j].second = -1;

	int sum = 0;

	for (int i = 0;i<n;i++) {
		sum += power[i];
		l[i + 1] = sum;
	}
	sum = 0;
	for (int i = 0;i<n;i++) {
		sum += power[n - 1 - i];
		r[n + 1 - 1 - i] = sum;
	}
	if (p[c]>minpos) {
		memo[c - 1][c].first = (p[c] - p[c - 1])*(l[c + 1 - 1] + r[c + 1 + 1]);
		memo[c - 1][c].second = INF;
	}
	if (p[c]<maxpos) {
		memo[c][c + 1].second = (p[c + 1] - p[c])*(r[c + 1 + 1] + l[c + 1 - 1]);
		memo[c][c + 1].first = INF;
	}
	int ans = min(dfs(0, n - 1).first, dfs(0, n - 1).second);
	cout << ans << endl;
	return 0;
}