Codeforces周赛 #765 (Div.2)：C. Road Optimization（线性DP / 图论）

C. Road Optimization

题意：

• 给定一条直线，起点为 0、终点为 m；直线上有 n 个告示牌，告诉你这 n 个告示牌的下标和分数

• 若一段路的两端有告示牌，这段路行驶花费的时间 == （两个告示牌的距离 * 左边告示牌的分数）

• 告诉你可以拆除 k 个告示牌，求从起点到终点的最小花费时间

• 起点必定有一个告示牌（不可拆）

DP解法：

状态集合：$dp[i][j]$ 表示 抵达 i 点拆除 刚好 j 个告示牌的最小花费时间

状态属性：$Min$

状态转移：

• 初始状态 $dp[0][0]=0$，起点到终点最小花费时间 = ${\sum }_{i=0}^{i\to k}dp[n-1][i]$ （不一定要拆完 k 个告示牌才能得到最小，枚举取Min即可）

• $for(i=0;i<n;i++)$
  $for(j=0;j<=k;j++)$
  两个 for 循环枚举每一种 $dp[i][j]$ 的状况；

• 对于每一个 i ，枚举 i 之后的位置 pos，pos 与 i 之间的告示牌数量为 $pos-i-1$（不包括两点），假定移除这些告示牌；

• 移除后，对于 pos点 拆除的告示牌总数量为 $g=j+pos-i-1$；

• i 走到 pos 的时间花费为 $b[i]\ast (a[pos]-a[i])$；

• 故有：
  $g=j+pos-i-1$
  $dp[pos][g]=min(dp[pos][g],dp[i][j]+b[i]\ast (a[pos]-a[i]))$

注意边界，和特殊状态（$i>=j$，拆除数量不可能大于当前告示牌数量）

代码：

#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define sca scanf
#define pri printf
#define ul (u << 1)
#define ur (u << 1 | 1)
#define fx first
#define fy second
//#pragma GCC optimize(2)
//[博客地址](https://blog.csdn.net/weixin_51797626?t=1) 
using namespace std;

typedef long long ll;
typedef pair<ll, int> PII;
typedef pair <ll, PII> PI;

const int N = 510, M = 500010, MM = N;
int INF = 0x3f3f3f3f, mod = 100003;
ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, T, S, D;
ll dp[N][N];
ll a[N], b[N];

int main() {
	cinios;

	cin >> n >> m >> k;
	for (int i = 0; i < n; i++)cin >> a[i];
	for (int i = 0; i < n; i++)cin >> b[i];
	a[n++] = m;//注意终点坐标也要放入

	mem(dp, 0x3f);
	for (int i = 0; i <= k; i++)dp[0][i] = 0;

	for (int i = 0; i < n; i++)
		for (int j = 0; j <= min(k, i); j++)//j <= min(k,i)
			for (int pos = i + 1; pos < n; pos++) {
				int g = j + pos - i - 1;

				if (g <= k)//转移的 g 不可能超过 k 限制
					dp[pos][g] = min(dp[pos][g], dp[i][j] + b[i] * (a[pos] - a[i]));
			}
				
	ll mi = LNF;//取min
	for (int i = 0; i <= k; i++)
		mi = min(mi, dp[n - 1][i]);

	cout << mi;

	return 0;
}
/*
*/

——————————————————————————————————————————

图论解法：

• 枚举两两点，连边，携带的信息就是 { 删去中间点的数量，删去中间点后的路段花费时间 }
• 可以发现图中边权都是正权，所以可以用 dijkstra 跑最短路

代码：

#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define sca scanf
#define pri printf
#define ul (u << 1)
#define ur (u << 1 | 1)
#define fx first
#define fy second
//#pragma GCC optimize(2)
//[博客地址](https://blog.csdn.net/weixin_51797626?t=1) 
using namespace std;

typedef long long ll;
typedef pair<int, int> PII;
typedef pair <ll, PII> PI;

const int N = 510, M = 500010, MM = N;
int INF = 0x3f3f3f3f, mod = 100003;
ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, T, S, D;
int h[N], e[M], ne[M], idx;
PII w[M];
ll dist[N][N];
bool st[N][N];//i 点 删去 j 条边
int a[N], b[N];

void add(int a, int b, int k, int len) {
	e[idx] = b, ne[idx] = h[a], w[idx] = { k,len }, h[a] = idx++;
}

void dj() {
	mem(dist, 0x3f);
	dist[1][0] = 0;

	priority_queue<PI, vector<PI>, greater<PI> >q;
	q.push({ 0,{0,1} });

	while (q.size())
	{
		PI t = q.top();
		q.pop();

		int ver = t.second.second, tk = t.second.first;
		if (st[ver][tk])continue;
		st[ver][tk] = true;

		for (int i = h[ver]; ~i; i = ne[i]) {
			int j = e[i], jk = w[i].first + tk;
			if (jk > k)continue;//超过限制的跳过

			if (dist[j][jk] > dist[ver][tk] + w[i].second) {
				dist[j][jk] = dist[ver][tk] + w[i].second;
				q.push({ dist[j][jk],{jk,j} });
			}
		}
	}
}

int main() {
	cinios;

	cin >> n >> m >> k;
	for (int i = 1; i <= n; i++)cin >> a[i];
	for (int i = 1; i <= n; i++)cin >> b[i];
	a[++n] = m;

	mem(h, -1);
	for (int i = 1; i < n; i++) {
		for (int j = i + 1; j <= n; j++) {
			add(i, j, j - i - 1, b[i] * (a[j] - a[i]));
			//两两点连边，携带的信息就是 {删去的中间点的数量，删去中间点后的路段花费时间}
		}
	}

	dj();

	ll mi = LNF;
	for (int i = 0; i <= k; i++)
		mi = min(mi, dist[n][i]);

	cout << mi;

	return 0;
}