换教室

今天做练习题的时候做到一道练习题叫换教室原以为是一道很复杂的题，但是实用了Floyd求得单源最短路劲之后就是一个简单的求期望，通过图表发现是一个二维控制的期望这里选择用dp来做，实用dp[i][j][k]来表示第i个时间段交换了j次教室k代表这次交换或者不交换dp太长了233这里就不写了思路应该是很明确的

题目：
链接：https://ac.nowcoder.com/acm/problem/16428
来源：牛客网

对于刚上大学的牛牛来说，他面临的第一个问题是如何根据实际情况申请合适的课程。
在可以选择的课程中，有 2n 节课程安排在 n 个时间段上。在第 i （1 ≤ i ≤ n）个时间段上，两节内容相同的课程同时在不同的地点进行，其中，牛牛预先被安排在教室 ci 上课，而另一节课程在教室 di 进行。
在不提交任何申请的情况下，学生们需要按时间段的顺序依次完成所有的 n 节安排好的课程。如果学生想更换第i节课程的教室，则需要提出申请。若申请通过，学生就可以在第 i 个时间段去教室 di 上课，否则仍然在教室 ci 上课。
由于更换教室的需求太多，申请不一定能获得通过。通过计算，牛牛发现申请更换第 i 节课程的教室时，申请被通过的概率是一个已知的实数 ki，并且对于不同课程的申请，被通过的概率是互相独立的。
学校规定，所有的申请只能在学期开始前一次性提交，并且每个人只能选择至多 m 节课程进行申请。这意味着牛牛必须一次性决定是否申请更换每节课的教室，而不能根据某些课程的申请结果来决定其他课程是否申请；牛牛可以申请白己最希望更换教室的 m 门课程，也可以不用完这 m 个申请的机会，甚至可以一门课程都不申请。
因为不同的课程可能会被安排在不同的教室进行，所以牛牛需要利用课问时间从一间教室赶到另一间教室。
牛牛所在的大学有 v 个教室，有 e 条道路。每条道路连接两间教室，并且是可以双向通行的。由于道路的长度和拥堵程度不同，通过不同的道路耗费的体力可能会有所不同。当第 i（1 ≤ i ≤ n - 1）节课结束后，牛牛就会从这节课的教室出发，选择一条耗费体力最少的路径前往下一节课的教室。
现在牛牛想知道，申请哪几门课程可以使他因在教室问移动耗费的体力值的总和的期望值最小，请你帮他求出这个最小值。
输入描述:
第一行四个整数 n，m，v，e 。n 表示这个学期内的时间段的数量；m 表示牛牛最多可以申请更换多少节课程的教室；v 表示牛牛学校里教室的数量；e 表示牛牛的学校里道路的数量。
第二行 n 个正整数，第 i（1 ≤ i ≤ n）个正整数表示 ci，即第 i 个时间段牛牛被安排上课的教室；保证 1 ≤ ci ≤ v。
第三行 n 个正整数，第 i（1 ≤ i ≤ n）个正整数表示 di，即第 i 个时间段另一间上同样课程的教室；保证 1 ≤ di ≤ v。
第四行 n 个实数，第 i（1 ≤ i ≤ n）个实数表示 ki，即牛牛申请在第 i 个时间段更换教室获得通过的概率。保证 0 ≤ ki ≤ 1。
接下来 e 行，每行三个正整数 aj, bj, wj，表示有一条双向道路连接教室 aj, bj，通过这条道路需要耗费的体力值是 Wj；保证 1 ≤ aj, bj ≤ v, 1 ≤ wj ≤ 100。
保证 1 ≤ n ≤ 2000，0 ≤ m ≤ 2000，1 ≤ v ≤ 300，0 ≤ e ≤ 90000。
保证通过学校里的道路，从任何一间教室出发，都能到达其他所有的教室。
保证输入的实数最多包含 3 位小数。
输出描述:
输出一行，包含一个实数，四舎五入精确到小数点后恰好 2 位，表示答案。你的输出必须和标准输出完全一样才算正确。
测试数据保证四舎五入后的答案和准确答案的差的绝对值不大于 4 x 103。（如果你不知道什么是浮点误差，这段话可以理解为：对于大多数的算法，你可以正常地使用浮点数类型而不用对它进行特殊的处理）
示例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
输出
复制
2.80
说明

代码：

#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include<iomanip>
#include<vector>
#include <cmath>
using namespace std;
int n; int m; int v; int e;
double d[310][310]; double c[2010];//Floyd的数组开int也可的，会帮你自动强制转换
int t1[2010]; int t2[2010];
double dp[2010][2010][2];
double res = 0x3f3f3f3f;
int main()
{
	cin >> n >> m >> v >> e;
	for (int i = 1; i <= n; i++)
	{
		cin >> t1[i];
	}
	for (int i = 1; i <= n; i++)
	{
		cin >> t2[i];
	}
	for (int i = 1; i <= n; i++)
	{
		cin >> c[i];
	}
	for (int i = 1; i <= v; i++)//记得自己的初值是0
	{
		for (int j = 1; j < i; j++)
		{
			d[i][j] = 0x3f3f3f3f;
			d[j][i] = 0x3f3f3f3f;
		}
	}
	for (int i = 1; i <= e; i++)
	{
		int u; int v; double val;
		cin >> u >> v >> val;
		d[u][v] = min(d[u][v], val);//注意重边和自环
		d[v][u] = d[u][v];
	}
	for (int k = 1; k <= v; k++)//Floyd的常数优化
	{
		for (int i = 1; i <= v; i++)
		{
			for (int j = 1; j < i; j++)//因为是双向边，所以求出d[i][j]就不必再求d[j][i]
			{
				if (d[i][j] > d[i][k] + d[k][j])
				{
					d[i][j] = d[i][k] + d[k][j];
					d[j][i] = d[i][j];
				}
			}
		}
	}
	for (int i = 1; i <= n; i++)
	{
		for (int j = 0; j <= m; j++)
		{
			for (int k = 0; k <= 1; k++)
			{
				dp[i][j][k] = 0x3f3f3f3f;
			}
		}
	}
	dp[1][0][0] = 0.0; dp[1][1][1] = 0.0;//边界条件
	for (int i = 2; i <= n; i++)
	{
		for (int j = 0; j <= m && j <= i; j++)//显然大于i的换法是不存在的
		{
			dp[i][j][0] =                                                   //这个点不换的方程
				min(dp[i - 1][j][0] + d[t1[i - 1]][t1[i]]                   //上一个点也不换
					, dp[i - 1][j][1] + d[t1[i - 1]][t1[i]] * (1.0 - c[i - 1]) +     //上一个点失败
					d[t2[i - 1]][t1[i]] * c[i - 1]);                                  //上一个点成功
			if (j >= 1)//防止越界
			{
				dp[i][j][1] =                                               //这个点换的方程
					min(dp[i - 1][j - 1][0] + d[t1[i - 1]][t2[i]] * c[i] +   //上一个点不换，这个点成功
						d[t1[i - 1]][t1[i]] * (1.0 - c[i]),                          //上一个点不换，这个点失败
						dp[i - 1][j - 1][1] + d[t2[i - 1]][t2[i]] * c[i - 1] * c[i] +//上一个点成功，这个点成功
						d[t2[i - 1]][t1[i]] * c[i - 1] * (1.0 - c[i]) +               //上一个点成功，这个点失败
						d[t1[i - 1]][t2[i]] * (1.0 - c[i - 1])*c[i] +               //上一个点失败，这个点成功
						d[t1[i - 1]][t1[i]] * (1.0 - c[i - 1])*(1.0 - c[i]));       //上一个点失败，这个点失败
			}
		}
	}
	for (int i = 0; i <= m; i++)
	{
		for (int j = 0; j <= 1; j++)
		{
			res = min(res, dp[n][i][j]);//找出最小值
		}
	}
	cout << setprecision(2) << res;
	return 0;
}