P1850 [NOIP2016 提高组] 换教室

转载

mob60475704ea1a 2021-10-14 20:07:00

P1850 [NOIP2016 提高组] 换教室

题目
思路
代码

题目

题目描述

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

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

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

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

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

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

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

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

输入格式

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

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

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

第四行 \(n\) 个实数，第 \(i\)（\(1 \leq i \leq 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 \leq n \leq 2000\)，\(0 \leq m \leq 2000\)，\(1 \leq v \leq 300\)，\(0 \leq e \leq 90000\)。

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

保证输入的实数最多包含 \(3\) 位小数。

输出格式

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

测试数据保证四舍五入后的答案和准确答案的差的绝对值不大于 \(4 \times 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说明】

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

【提示】

道路中可能会有多条双向道路连接相同的两间教室。也有可能有道路两端连接的是同一间教室。

请注意区分n,m,v,e的意义, n不是教室的数量, m不是道路的数量。

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

特殊性质2:对于所有的 \(1≤ i≤ n\)， \(k_i= 1\) 。

思路

期望基础而稍微毒瘤的题目.

看到\(v\)的范围直接先跑一遍Floyd.不难想到设\(f_{i,j}\)表示前上了前\(i\)个课程,有\(j\)个课程申请了换教室的期望路径长度为\(f_{i,j}\).推一下你就可以发现由于不能确定上一个课程的教室,没办法转移(不知道上一个有没有申请,申请后有没有成功).

所以我们增加一个维度,\(f_{i,j,0/1}\)表示前上了前\(i\)个课程,其中第\(i\)个课程申请(1)/不申请(0)换教室,有\(j\)个课程申请了换教室的期望路径长度为\(f_{i,j}\).

那我们如何确定上一个课程有没有申请成功呢?这其实就是期望的一部分(我只能这么说了,我能理解的话感受一下).

转移方程:

\[f_{i,j,0}=\min \begin{cases} f_{i-1,j,0}+\operatorname{dis}(c_{i-1},c_i)\\ f_{i-1,j,1}+\operatorname{dis}(c_{i-1},c_i)\cdot (1-k_{i-1})+\operatorname{dis}(d_{i-1},c_i)\cdot k_{i-1} \end{cases} \]

其中,我们讨论的前一个点的申请是否被允许的情况,并乘上了概率,就是期望.

对于\(f_{i,j,1}\)更为复杂一些,需要讨论第\(i\),\(i-1\)号点的申请通过情况(共4种),~~我就懒得写了~~,可以自己推一下.

代码

#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
template <class T>
T read() {
	T re = 0;
	char c = getchar();
	bool negt = false;
	while(c < '0' || c > '9')
		negt |= (c == '-') , c = getchar();
	while(c >= '0' && c <= '9')
		re = (re << 1) + (re << 3) + c - '0' , c = getchar();
	return negt ? -re : re;
}
double readf() {
	double re = 0;
	char c = getchar();
	bool negt = false;
	while(c < '0' || c > '9')	negt |= (c == '-') , c = getchar();
	while(c >= '0' && c <= '9')	re = re * 10 + c - '0' , c = getchar();
	if(c == '.') {
		double w = 1e-1;
		c = getchar();
		while(c >= '0' && c <= '9')re = re + w * (c - '0') , w /= 10 , c = getchar();
	}
	return negt ? -re : re;
}

const int N = 2e3 ,  M = 2e3 , V = 300 , E = 9e4;

int n , m , v , e ;
int dis[V + 10][V + 10];

double k[N + 10];
int c[N + 10];
int d[N + 10];

double f[N + 10][M + 10][2];

void Floyd() {
	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]);
}

const double finf = 1 / 0.0;
void DP() {
#define dis(_ , __) ((_) == 0 || (__) == 0 ? 0 : dis[_][__])
	for(int i = 0 ; i < N ; i++)
		for(int j = 0 ; j < M ; j++)
			f[i][j][0] = f[i][j][1] = finf;
	
	f[1][0][0] = 0 , f[0][0][0] = 0;
	for(int i = 2 ; i <= n ; i++)
		f[i][0][0] = f[i - 1][0][0] + dis(c[i] , c[i - 1]) , f[i][0][1] = finf;

	for(int j = 1 ; j <= m ; j++) {
		f[j - 1][j][0] = f[j - 1][j][1] = finf;
		for(int i = j ; i <= n ; i++) {
			f[i][j][0] = min(
			                 f[i - 1][j][0] + dis(c[i] , c[i - 1])
			                 ,
			                 f[i - 1][j][1] + (
			                     dis(c[i] , c[i - 1]) * (1 - k[i - 1])
			                     + dis(c[i] , d[i - 1]) * k[i - 1]
			                 )
			             );
			f[i][j][1] = min(
			                 f[i - 1][j - 1][0] + (
			                     dis(c[i - 1] , c[i]) * (1 - k[i])
			                     + dis(c[i - 1] , d[i]) * k[i]
			                 )
			                 ,
			                 f[i - 1][j - 1][1] + (
			                     dis(c[i - 1] , c[i]) * (1 - k[i - 1]) * (1 - k[i])
			                     + dis(c[i - 1] , d[i]) * (1 - k[i - 1]) * k[i]
			                     + dis(d[i - 1] , c[i]) * k[i - 1] * (1 - k[i])
			                     + dis(d[i - 1] , d[i]) * k[i - 1] * k[i]
			                 )
			             );
		}
	}
	
	double ans = finf;
	for(int i = 0 ; i <= m ; i++)
		ans = min(ans , min(f[n][i][0] , f[n][i][1]));
	printf("%.2f" , ans);
#undef dis
}
int main() {
	memset(dis , 0x3f , sizeof(dis));

	n = read<int>() , m = read<int>() , v = read<int>() , e = read<int>();
	for(int i = 1 ; i <= n ; i++)
		c[i] = read<int>();
	for(int i = 1 ; i <= n ; i++)
		d[i] = read<int>();
	for(int i = 1 ; i <= n ; i++)
		k[i] = readf();

	for(int i = 1 ; i <= e ; i++) {
		int x = read<int>() , y = read<int>() , len = read<int>();
		dis[x][y] = dis[y][x] = min(len , dis[x][y]);
	}
	for(int i = 1 ; i <= v ; i++)
		dis[i][i] = 0;

	Floyd();
	DP();

	return 0;
}
/*
2 1 4 6 
3 1
4 2
0.027 0.679
1 2 20
1 3 22 
1 4 21
2 3 22
2 4 12 
3 4 17
 
*/

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。