【P1850】换教室 Floyd+期望DP

Description

对于刚上大学的牛牛来说, 他面临的第一个问题是如何根据实际情况中情合适的课程。
在可以选择的课程中,有2n节课程安排在n个时间段上。在第 i ( 1≤ i≤n)个时同段上, 两节内容相同的课程同时在不同的地点进行, 其中, 牛牛预先被安排在教室 ci上课, 而另一节课程在教室 di进行。
在不提交任何申请的情况下,学生们需要按时间段的顺序依次完成所有的n节安排好的课程。如果学生想更换第i节课程的教室,则需要提出中情。若申请通过,学生就可以在第 i个时间段去教室 di上课, 否则仍然在教室 ci上课。
由于更换教室的需求太多, 申请不一定能获得通过。 通过计算, 牛牛发现申请更换第 i节课程的教室时, 中情被通过的概率是一个已知的实数 ki, 并且对于不同课程的申请, 被通过的概率是互相独立的。
学校规定, 所有的申请只能在学期开始前一次性提交, 并且每个人只能选择至多m节课程进行申请。 这意味着牛牛必须一次性决定是否申请更换每节课的教室, 而不能根据某些课程的申请结果来决定其他课程是否申请; 牛牛可以申请白己最希望更换教室的 m门课程,也可以不用完这m个中情的机会,甚至可以一门课程都不申请。
因为不同的课程可能会被安排在不同的教室进行, 所以牛牛需要利用课问时间从一间教室赶到另一间教室。
牛牛所在的大学有 v个教室,有 e条道路。每条道路连接两间教室, 并且是可以双向通行的。 由于道路的长度和拥;i者程度不同, 通过不同的道路耗费的体力可能会有所不同。当第i ( 1≤i≤n-1 )节课结束后,牛牛就会从这节课的教室出发,选择一条耗费体力最少的路径前往下一节课的教室。
现在牛牛想知道,申请哪几门课程可以使他因在教室问移动耗费的体力值的总和的期望值最小,请你帮他求出这个最小值。

Input

第一行四个整数 n,m,v,e 。 n表示这个学期内的时间段的数量; m表示牛牛最多可以申请更换多少节课程的教室; v表示牛牛学校里教室的数量; e表示牛牛的学校里道路的数量。
第二行n个正整数,第 i ( 1≤ i≤ n)个正整数表示c,,即第 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位小数。
1. 道路中可能会有多条双向道路连接相同的两间教室。 也有可能有道路两端连接
的是同一间教室。
2. 请注意区分n,m,v,e的意义, n不是教室的数量, m不是道路的数量。

Output

输出一行,包含一个实数,四舎五入精确到小数点后恰好2位,表示答案。你的
输出必须和标准输出完全一样才算正确。
测试数据保证四舎五入后的答案和准确答案的差的绝对值不大于4 *10^-3 。 (如果你不知道什么是浮点误差, 这段话可以理解为: 对于大多数的算法, 你可以正常地使用浮点数类型而不用对它进行特殊的处理)

题解

1.因为要求体力的期望最小，所以我们首先要保证每一次移动都是要走最短的路径，由于是多源再加$v$的范围非常可观，直接$Floyd$预处理出各个教室间的最短路
2.考虑进行Dp，因为要求换教室的数量不超过$m$，对于每一个时间段有选择换和不选择换的状态，所以我们设状态$f[i][j][k]$表示第$i$时间段，已经申请换了$j$个教室，第$i$个时间段申请换则为$1$，不申请换则为$0$.
由于题目中给出了申请成功的概率$k,k \in [0,1]$，那么申请不成功的概率就为$1-k$.
转移方程就可以得到。

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#define INF 0x7f7f7f7f
using namespace std;
int G[302][302],c[3000],d[3000],n,m,v,e;
double f[3000][3000][2],k[3000],ans=99999999.999;
void Floyd()//预处理出最短路径 
{
    for(int K=1;K<=v;K++)
        for(int i=1;i<=v;i++)
            for(int j=1;j<=v;j++)
                if(G[i][K]!=INF&&G[K][j]!=INF)
                G[i][j]=min(G[i][j],G[i][K]+G[K][j]);
}
void Dp()
{
    f[1][0][0]=0; 
    f[1][0][1]=INF;//初始化 
//  memset(f,INF,sizeof(f));
    for(int i=2;i<=n;i++)
    {
        f[i][0][0]=f[i-1][0][0]+G[c[i-1]][c[i]];//初始化，不换的话就一直在c[i]上下去 
        f[i][0][1]=INF;//初始化 
        for(int j=1;j<=m;j++)//转移方程
        {
                f[i][j][0]=f[i][j][1]=INF;
            if(f[i-1][j][0]!=INF)
                f[i][j][0]=min(f[i][j][0],f[i-1][j][0]+G[c[i-1]][c[i]]);
            if(f[i-1][j][1]!=INF)
                f[i][j][0]=min(f[i][j][0],f[i-1][j][1]
                    +G[d[i-1]][c[i]]*k[i-1]
                    +G[c[i-1]][c[i]]*(1-k[i-1]));
            if(f[i-1][j-1][0]!=INF)
                f[i][j][1]=min(f[i][j][1],f[i-1][j-1][0]
                    +G[c[i-1]][d[i]]*k[i]
                    +G[c[i-1]][c[i]]*(1-k[i]));
            if(f[i-1][j-1][1]!=INF)
                f[i][j][1]=min(f[i][j][1],f[i-1][j-1][1]
                    +G[c[i-1]][c[i]]*(1-k[i-1])*(1-k[i])
                    +G[c[i-1]][d[i]]*(1-k[i-1])*k[i]
                    +G[d[i-1]][c[i]]*(k[i-1])*(1-k[i])
                    +G[d[i-1]][d[i]]*k[i-1]*k[i]);
        }
    }
    for(int i=0;i<=m;i++) ans=min(ans,f[n][i][0]),ans=min(ans,f[n][i][1]);//要从0开始因为有可能一个都不换 
    printf("%.2f",ans);
}
int main()
{
    memset(G,0x7f7f7f7f,sizeof(G));
    scanf("%d%d%d%d",&n,&m,&v,&e);
    for(int i=1;i<=n;i++) scanf("%d",&c[i]);
    for(int i=1;i<=n;i++) scanf("%d",&d[i]);
    for(int i=1;i<=n;i++) scanf("%lf",&k[i]);
    for(int i=1;i<=e;i++)
    {
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        G[x][y]=min(G[x][y],z);//去重边 
        G[y][x]=G[x][y];
    }
    for(int i=1;i<=v;i++) G[i][i]=0;
    Floyd();
    /*for(int i=1;i<=v;i++)
    {
        for(int j=1;j<=v;j++)
        {
            cout<<G[i][j]<<" ";
        }
        cout<<endl;
    }*/
    Dp();
    return 0;
}