[NOIP2016 D1T3]换教室 【floyd+概率dp】

题目描述

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

在可以选择的课程中，有 2n2n 节课程安排在 nn 个时间段上。在第 ii（1
\leq i \leq n1≤i≤n）个时间段上，两节内容相同的课程同时在不同的地点进行，其中，牛牛预先被安排在教室 c_ic​i​​ 上课，而另一节课程在教室 d_id​i​​ 进行。

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

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

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

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

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

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

输入输出格式

输入格式：

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

第二行 nn 个正整数，第 ii（1
\leq i \leq n1≤i≤n）个正整数表示 c_ic​i​​，即第 ii 个时间段牛牛被安排上课的教室；保证 1
\le c_i \le v1≤c​i​​≤v。

第三行 nn 个正整数，第 ii（1
\leq i \leq n1≤i≤n）个正整数表示 d_id​i​​，即第 ii 个时间段另一间上同样课程的教室；保证 1
\le d_i \le v1≤d​i​​≤v。

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

接下来 ee 行，每行三个正整数 a_j,
b_j, w_ja​j​​,b​j​​,w​j​​，表示有一条双向道路连接教室 a_j,
b_ja​j​​,b​j​​，通过这条道路需要耗费的体力值是 w_jw​j​​；保证 1
\le a_j, b_j \le v1≤a​j​​,b​j​​≤v， 1
\le w_j \le 1001≤w​j​​≤100。

保证 1
\leq n \leq 20001≤n≤2000，0
\leq m \leq 20000≤m≤2000，1
\leq v \leq 3001≤v≤300，0
\leq e \leq 900000≤e≤90000。

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

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

输出格式：

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

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

输入输出样例

输入样例#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:图上任意两点 ai, bi, ai≠ bi间,存在一条耗费体力最少的路径只包含一条道路。

特殊性质2:对于所有的1≤ i≤ n， ki= 1 。

题解

floyd算法

floyd算法是解决的所有点对之间的最短路的算法，复杂度O(n^3)

采用的是dp的思想，每次以一个节点为中介点更新最短路

d[i][j]表示i->j的最短路，初始d[i][j]要么为边权要么为INF

代码极其简洁：

void floyd(){
	for(int k=1;k<=n;k++)
		for(int i=1;i<=n;i++)
			for(int j=1;j<=n;j++)
				if(d[i][k]+d[k][j]<d[i][j])
					d[i][j]=d[i][k]+d[k][j];
}

概率dp

概率dp，顾名思义，就是有关概率的dp，它的状态通常是f.....[1],f......[0]，1、0等表示选择，转移时各自乘上各自实现的概率进行转移

本题题解

首先v<=300明显可以要用floyd算法算出点对最短路

然后设f[i][j][0 or 1]为i时刻总共用了j次申请机会到 0号或1号【表示该时刻的两个教室】 教室的最短路径

根据概率dp的思想，状态转移方程就是这样的：

f[i][j][0]=min(f[i-1][j][0]+d[a[i-1]][a[i]],f[i-1][j][1]+d[a[i-1]][a[i]]*(1-c[i-1])+d[b[i-1]][a[i]]*c[i-1]);
			f[i][j][1]=min(f[i-1][j-1][0]+d[a[i-1]][a[i]]*(1-c[i])+d[a[i-1]][b[i]]*c[i],
							f[i-1][j-1][1]
							+d[a[i-1]][a[i]]*(1-c[i-1])*(1-c[i])
							+d[b[i-1]][a[i]]*c[i-1]*(1-c[i])
							+d[a[i-1]][b[i]]*(1-c[i-1])*c[i]
							+d[b[i-1]][b[i]]*c[i-1]*c[i]);

= =方程太长，反正就是分类讨论嘛

然后初始化第一个时间点f[1][0][0]=f[1][1][1]=0

其他时间为INF

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define LL long long int
using namespace std;
const int maxn=2005,maxv=305,INF=1000000000,P=1000000007;

inline int read(){
	int out=0,flag=1;char c=getchar();
	while(c<48||c>57) {if(c=='-') flag=-1;c=getchar();}
	while(c>=48&&c<=57){out=out*10+c-48;c=getchar();}
	return out*flag;
}

int n,m,v,e,a[maxn],b[maxn];
int d[maxv][maxv];
double c[maxn],f[maxn][maxn][2];

void init(){
	int x,y,z;
	n=read();m=read();v=read();e=read();
	for(int i=1;i<=n;i++) a[i]=read();
	for(int i=1;i<=n;i++) b[i]=read();
	for(int i=1;i<=n;i++) scanf("%lf",&c[i]);
	fill(d[0],d[0]+maxv*maxv,INF);
	for(int i=1;i<=v;i++) d[i][i]=0;
	while(e--){
		x=read();
		y=read();
		z=read();
		if(x==y) continue;
		if(z<d[x][y]) d[x][y]=d[y][x]=z;
	}
}

void floyd(){
	for (int k=1; k<=v; k++)
		for (int i=1; i<=v; i++)
			for (int j=1; j<=v; j++)
				if (d[i][k] + d[k][j] < d[i][j])
					d[i][j] = d[i][k] + d[k][j];
}

void solve(){
	for (int i=0; i<n; i++)
        for (int j=0; j<n; j++)
            f[i][j][0] = f[i][j][1] = INF;
    f[1][0][0] = 0; f[1][1][1] = 0;
	for(int i=2;i<=n;i++){
		f[i][0][0]=f[i-1][0][0]+d[a[i-1]][a[i]];
		for(int j=1;j<=min(i,m);j++){
			f[i][j][0]=min(f[i-1][j][0]+d[a[i-1]][a[i]],f[i-1][j][1]+d[a[i-1]][a[i]]*(1-c[i-1])+d[b[i-1]][a[i]]*c[i-1]);
			f[i][j][1]=min(f[i-1][j-1][0]+d[a[i-1]][a[i]]*(1-c[i])+d[a[i-1]][b[i]]*c[i],
							f[i-1][j-1][1]
							+d[a[i-1]][a[i]]*(1-c[i-1])*(1-c[i])
							+d[b[i-1]][a[i]]*c[i-1]*(1-c[i])
							+d[a[i-1]][b[i]]*(1-c[i-1])*c[i]
							+d[b[i-1]][b[i]]*c[i-1]*c[i]);
		}
	}
}

void print(){
	double ans=f[n][0][0];
	for(int i=1;i<=m;i++){
		if(f[n][i][0]<ans) ans=f[n][i][0];
		if(f[n][i][1]<ans) ans=f[n][i][1];
	}
	printf("%.2lf\n",ans);
}

int main(){
	init();
	floyd();
	solve();
	print();
	return 0;
}