P1850 [NOIP2016 提高组] 换教室

[NOIP2016 提高组] 换教室

题目描述

对于刚上大学的牛牛来说，他面临的第一个问题是如何根据实际情况申请合适的课程。

在可以选择的课程中，有 $2n$ 节课程安排在 $n$ 个时间段上。在第 $i$（$1\le i\le n$）个时间段上，两节内容相同的课程同时在不同的地点进行，其中，牛牛预先被安排在教室 $c_i$ 上课，而另一节课程在教室 $d_i$ 进行。

在不提交任何申请的情况下，学生们需要按时间段的顺序依次完成所有的 $n$ 节安排好的课程。如果学生想更换第 $i$ 节课程的教室，则需要提出申请。若申请通过，学生就可以在第 $i$ 个时间段去教室 $d_i$ 上课，否则仍然在教室 $c_i$ 上课。

由于更换教室的需求太多，申请不一定能获得通过。通过计算，牛牛发现申请更换第 $i$ 节课程的教室时，申请被通过的概率是一个已知的实数 $k_i$，并且对于不同课程的申请，被通过的概率是互相独立的。

学校规定，所有的申请只能在学期开始前一次性提交，并且每个人只能选择至多 $m$ 节课程进行申请。这意味着牛牛必须一次性决定是否申请更换每节课的教室，而不能根据某些课程的申请结果来决定其他课程是否申请；牛牛可以申请自己最希望更换教室的 $m$ 门课程，也可以不用完这 $m$ 个申请的机会，甚至可以一门课程都不申请。

因为不同的课程可能会被安排在不同的教室进行，所以牛牛需要利用课间时间从一间教室赶到另一间教室。

牛牛所在的大学有 $v$ 个教室，有 $e$ 条道路。每条道路连接两间教室，并且是可以双向通行的。由于道路的长度和拥堵程度不同，通过不同的道路耗费的体力可能会有所不同。 当第 $i$（$1\le i\le n-1$）节课结束后，牛牛就会从这节课的教室出发，选择一条耗费体力最少的路径前往下一节课的教室。

现在牛牛想知道，申请哪几门课程可以使他因在教室间移动耗费的体力值的总和的期望值最小，请你帮他求出这个最小值。

输入格式

第一行四个整数 $n,m,v,e$。$n$ 表示这个学期内的时间段的数量；$m$ 表示牛牛最多可以申请更换多少节课程的教室；$v$ 表示牛牛学校里教室的数量；$e$表示牛牛的学校里道路的数量。

第二行 $n$ 个正整数，第 $i$（$1\le i\le n$）个正整数表示 $c_i$，即第 $i$ 个时间段牛牛被安排上课的教室；保证 $1\le c_i\le v$。

第三行 $n$ 个正整数，第 $i$（$1\le i\le n$）个正整数表示 $d_i$，即第 $i$ 个时间段另一间上同样课程的教室；保证 $1\le d_i\le v$。

第四行 $n$ 个实数，第 $i$（$1\le i\le n$）个实数表示 $k_i$，即牛牛申请在第 $i$ 个时间段更换教室获得通过的概率。保证 $0\le k_i\le 1$。

接下来 $e$ 行，每行三个正整数 $a_j,b_j,w_j$，表示有一条双向道路连接教室 $a_j,b_j$，通过这条道路需要耗费的体力值是 $w_j$；保证 $1\le a_j,b_j\le v$， $1\le w_j\le 100$。

保证 $1\le n\le 2000$，$0\le m\le 2000$，$1\le v\le 300$，$0\le e\le 90000$。

保证通过学校里的道路，从任何一间教室出发，都能到达其他所有的教室。

保证输入的实数最多包含 $3$ 位小数。

输出格式

输出一行，包含一个实数，四舍五入精确到小数点后恰好$2$位，表示答案。你的输出必须和标准输出完全一样才算正确。

测试数据保证四舍五入后的答案和准确答案的差的绝对值不大于 $4\times {10}^{-3}$。 （如果你不知道什么是浮点误差，这段话可以理解为：对于大多数的算法，你可以正常地使用浮点数类型而不用对它进行特殊的处理）

样例 #1

样例输入 #1

3 2 3 3
2 1 2
1 2 1
0.8 0.2 0.5 
1 2 5
1 3 3
2 3 1

样例输出 #1

2.80

提示

【样例1说明】

所有可行的申请方案和期望收益如下表:

【提示】

1. 道路中可能会有多条双向道路连接相同的两间教室。 也有可能有道路两端连接的是同一间教室。
2. 请注意区分n,m,v,e的意义, n不是教室的数量, m不是道路的数量。

特殊性质1:图上任意两点 $a_i$, $b_i$, $a_i$≠ $b_i$间,存在一条耗费体力最少的路径只包含一条道路。

特殊性质2:对于所有的 $1\le i\le n$， $k_i=1$ 。

Solution

期望 $\mathtt{\text{DP}}$ 的基础题，用来练手真的是个很不错的选择。

可以发现这道题与最短路是相关的，并且点数的规模只有 $300$，那就先用 Floyd 跑个最短路存入 $dis$ 再说。

设 $f[i][j][0/1]$ 表示前 $i$ 个换了 $j$ 个并且第 $i$ 个换（$1$）或是不换（$0$）。那么分类讨论：

先考虑 $f[i][j][0]$ 的转移情况。

可以发现 $f[i][j][0]=min\{$

• 上一个换，换成功了：$+f[i-1][j][1]+k[i-1]\times dis(d_{i-1},c_i)$

• 上一个换，换失败了：$+(1-k[i-1])\times dis(c_{i-1},c_i),$

• 上一个不换：$f[i-1][j][0]+dis(c_{i-1},c_i)\}$

对于 $f[i][j][1]$ 的转移就要更复杂一点：

$f[i][j][1]=min\{$

• 上一个不换，当前这个换，换成功了：$f[i-1][j-1][0]+k[i]\times dis(c_{i-1},d_i)$

• 上一个不换，当前这个换，换失败了：$+(1-k[i])\times dis(c_{i-1},c_i),$

• 上一个换，换成功了，当前这个换，换成功了：$f[i][j-1][1]+k[i-1]\times k[i]\times dis(d_{i-1},d_i)$

• 上一个换，换成功了，当前这个换，换失败了：$+k[i-1]\times (1-k[i])\times dis(d_{i-1},c_i)$

• 上一个换，换失败了，当前这个换，换成功了：$+(1-k[i-1])\times k[i]\times dis(c_{i_1},d_i)$

• 上一个换，换失败了，当前这个换，换失败了：$+(1-k[i-1])\times (1-k[i])\times dis(c_{i-1},c_i)\}$

完整代码

需要注意 Floyd 的自环不能赋值为 $inf$，并且需要注意方程的括号匹配问题。

#include<bits/stdc++.h>
using namespace std;
int dis[305][305];
constexpr int _SIZE = 2e3;
int n, m, v, e;
int c[_SIZE + 5], d[_SIZE + 5];
double k[_SIZE + 5];
double f[2][_SIZE + 5];
signed main() {
	ios::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);
	cin >> n >> m >> v >> e;
	memset(dis, 0x3f, sizeof dis);
	for (int i = 1; i <= n; i++) cin >> c[i];
	for (int i = 1; i <= n; i++) cin >> d[i];
	for (int i = 1; i <= n; i++) cin >> k[i];
	for (int i = 1; i <= v; i++) dis[i][i] = 0;
	for (int i = 1; i <= e; i++) {
		int u, v, l;
		cin >> u >> v >> l;
		int temp = min(dis[u][v], l);
		dis[u][v] = dis[v][u] = temp;
	}
	for (int k = 1; k <= v; k++)
		for (int i = 1; i <= v; i++)
			for (int j = 1; j <= v; j++)
				dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
	memset(f, 127, sizeof f);
	f[0][0] = 0, f[1][1] = 0;
	for (int i = 2; i <= n; i++) {
		for (int j = i; j >= 0; j--) {
			f[0][j] = min(f[1][j] + k[i - 1] * dis[d[i - 1]][c[i]] + 
									(1 - k[i - 1]) * dis[c[i - 1]][c[i]], 
							 f[0][j] + dis[c[i - 1]][c[i]]);

			if (j == 0) continue;

			f[1][j] = min(f[0][j - 1] + k[i] * dis[c[i - 1]][d[i]] + 
									(1 - k[i]) * dis[c[i - 1]][c[i]], 
							 f[1][j - 1] + k[i - 1] * k[i] * dis[d[i - 1]][d[i]] + 
									k[i - 1] * (1 - k[i]) * dis[d[i - 1]][c[i]] +
									(1 - k[i - 1]) * k[i] * dis[c[i - 1]][d[i]] + 
									(1 - k[i - 1]) * (1 - k[i]) * dis[c[i - 1]][c[i]]);
		}
	}
	double ans = 1145141919810.0;
	for (int i = 0; i <= m; i++) ans = min({ans, f[0][i], f[1][i]});
	cout << fixed << setprecision(2) << ans << '\n';
	return 0;
}