【NOIP2016】Day1 T3 换教室（期望DP）

题目背景

NOIP2016 提高组 Day1 T3

题目描述

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

在可以选择的课程中，有 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×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

输出

2.80

备注

【样例1说明】

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

    

【提示】

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

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

【数据规模与约定】

    

特殊性质1：图上任意两点 ai，bi，ai≠bi 间 ，存在一条耗费体力最少的路径只包含一条道路。

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

【题目分析】

 期望Dp。

设$dp(i, j, 0)$表示在第$i$个时间已经提交$j$份申请，本次不提交申请的总期望。

　　同理$dp(i, j, 1)$表示在第$i$个时间已经提交$j(要加上这次的)$份申请，本次提交申请的总期望。

初始化$dp(1, 1, 0) = dp(1, 0, 0) = 0$

那么考虑转移：

对于$dp(i + 1, j, 0)$, 分两种情况：

• 上一次未提出申请，那他一定还在$c_{i}$处，只需加上$dis(c[i], c[i + 1])$
• 上一次提出了申请，那么他有$p_{i}$的几率成功（现在在$d_{i}$），加上$p_{i} × dis(d[i], c[i + 1])$

　　　当然也有$1 - p_{i}$的几率失败（现在在$c_{i}$），加上$(1 - p_{i}) × dis(c[i], c[i + 1])$。综上即

　　　　$$dp[i + 1][j][0] = min(dp[i][j][0] + dis[c[i]][c[i + 1]], dp[i][j][1] + p[i] × dis[d[i]][c[i + 1]] + (1 - p[i]) × dis[c[i]][c[i + 1]])$$

　　对于$dp(i + 1, j + 1, 1)$，也分两种情况：

• 上一次未提出申请， 那他一定还在$c_{i}$处，这次申请有$p_{i + 1}$的几率成功（去$d_{i + 1}$），加上$p_{i + 1} × dis(c[i], d[i + 1])$

　　　　当然也有$1 - p_{i + 1}$的几率失败（去$c_{i + 1}$），加上$(1 - p_{i + 1}) × dis(c[i], c[i + 1])$

• 上一次提出了申请，上一次有$p_{i}$的几率成功（现在在$d_{i}$），这次有$p_{i + 1}$的概率成功（去$d_{i + 1}$），加（同理）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　    这次有$1 - p_{i + 1}$的概率失败（去$c_{i + 1}$），加（同理）

　　　　　　　　　　　　

　　　　　　　　　　　　上一次有$1 - p_{i}$的几率成功（现在在$c_{i}$），这次有$p_{i + 1}$的概率成功（去$d_{i + 1}$），加（同理）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　    这次有$1 - p_{i + 1}$的概率失败（去$c_{i + 1}$），加（同理）

　　具体可以看代码：

【CODE】

#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<vector>
using namespace std;

const int N = 2005, M = 2005, V = 305, E = 90005, oo = 0x3f3f3f3f;
int dis[V][V], c[N], d[N], n, m, v, e;
double dp[N][N][2];
double p[N], ans = oo;

inline int Re(){
    int i = 0, f = 1; char ch = getchar();
    for(; (ch < '0' || ch > '9') && ch != '-'; ch = getchar());
    if(ch == '-') f = -1, ch = getchar();
    for(; ch >= '0' && ch <= '9'; ch = getchar())
        i = (i << 3) + (i << 1) + (ch - '0');
    return i * f;
}

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

inline void init(){
    for(int i = 1; i <= v; i++)
            for(int j = i; j <= v; j++)
                if(i != j) dis[i][j] = dis[j][i] = oo;
    for(int i = 1; i <= n; i++)
        for(int j = 0; j <= m; j++)
            dp[i][j][0] = dp[i][j][1] = oo;
    dp[1][1][1] = dp[1][0][0] = 0;
}

inline void Dp(){
    for(int i = 1; i <= n; i++)
        for(int j = 0; j <= m; j++){
            dp[i + 1][j][0] = min(dp[i][j][0] + (double)dis[c[i]][c[i + 1]], 
                                  dp[i][j][1] + p[i] * (double)dis[d[i]][c[i + 1]] + (1 - p[i]) * (double)dis[c[i]][c[i + 1]]);
            //---------------------------------------------------------------------------------------------------------------------------                          
            dp[i + 1][j + 1][1] = min(dp[i][j][0] + p[i + 1] * (double)dis[c[i]][d[i + 1]] + (1 - p[i + 1]) * (double)dis[c[i]][c[i + 1]], 
                                      //---------------------------------------------------------------------------------------------------
                                      dp[i][j][1] + 
                                      p[i] * p[i + 1] * (double)dis[d[i]][d[i + 1]] + 
                                      p[i] * (1.0 - p[i + 1]) * (double)dis[d[i]][c[i + 1]] +
                                      (1.0 - p[i]) * p[i + 1] * (double)dis[c[i]][d[i + 1]] +
                                      (1.0 - p[i]) * (1.0 - p[i + 1]) * (double)dis[c[i]][c[i + 1]]);
        }
    for(int i = 0; i <= m; i++)
        ans = min(ans, min(dp[n][i][0], dp[n][i][1]));
}
int main(){
    n = Re(), m = Re(), v = Re(), e = Re();
    for(int i = 1; i <= n; i++) c[i] = Re();
    for(int i = 1; i <= n; i++) d[i] = Re();
    for(int i = 1; i <= n; i++) scanf("%lf", &p[i]);
    init();
    for(int i = 1; i <= e; i++){
        int a = Re(), b = Re(), w = Re();
        dis[a][b] = min(dis[a][b], w);
        dis[b][a] = min(dis[b][a], w);
    }
    Floyed();
    Dp();
    printf("%.2f\n", ans);
    return 0;
}

View Code

 

转载于:https://www.cnblogs.com/CzYoL/p/7216752.html