资源分配dp&&换教室

资源分配dp

问题描述：资源分配问题一般包含3个核心数据：资源（本金）、物品（商品）和收益（利润），目标是要在给定的资源和物品（成本、价值）的情况下，如何为每种物品分配资源，从而使得收益最大化。背包问题是一种典型的资源分配问题。 

资源分配DP的状态一般定义为：状态d(i,j) 表示对前i个物品花费j单位资源可以获得的最大收益。 

---

换教室

题目描述

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

在可以选择的课程中，有 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）节课结束后，牛牛就会从这节课的教室出发，选择一条耗费体力最少的路径前往下一节课的教室。

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

输入格式

从文件classroom.in中读入数据。

第一行四个整数 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位小数。

输出格式

输出到文件classroom.ou中。

输出一行，包含一个实数，四舍五入精确到小数点后恰好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

输出样例1：复制

2.80

说明

【样例1说明】

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

【提示】

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

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

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

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

【耗时限制】1000ms 【内存限制】256MB

---

期望值的计算：设时间段i-1在c[i-1]教室，时间段i申请换到d[i]教室，体力消耗期望值为：dis(c[i-1], d[i]) * k[i] + dis(c[i-1], c[i]) * (1 - k[i]);

由于每次都走最短路，首先求出任意两个教室之间的最短路(floyd)。        

定义状态：dp[i][j]表示为前i个时间段分配j次申请机会，可以获得的最小期望体力消耗。

问题：对i进行决策时需要知道i-1的情况，否则无法计算体力消耗期望值，将信息加入状态。

定义状态：dp[i][j][0/1]表示为前i个时间段分配j次申请机会，且时间段i没申请/申请的最优解。状态转移方程：对第i个时间段进行决策（是否申请更换教室）

① i-1没申请：dp[i][j][0] = dp[i-1][j][0] + dis(c[i-1], c[i]) i时间段不申请更换教室，更新dp[i][j][0]，取决策中体力消耗的较小者：

② i-1申请了：dp[i][j][0] = dp[i-1][j][1] + dis(d[i-1], [c[i])*k[i-1] + dis(c[i-1]], c[i])*(1-k[i-1]);

i 时间段申请更换教室，更新dp[i][j][1]，取决策中体力消耗的较小者：

① i-1没申请：dp[i][j][1] = dp[i-1][j-1][0] + dis(c[i-1], d[i])*k[i] + dis(c[i-1], c[i])*(1-k[i])；

② i-1申请了：(4种组合：(i-1和i都申请成功)(i-1成功，i失败)(i-1失败，i成功)(i-1和i都失败))

dp[i][j][1] = dp[i-1][j-1][1] + dis(d[i-1], d[i])*k[i-1]*k[i]

                                      + dis(d[i-1], c[i])*k[i-1]*(1-k[i])

                                       + dis(c[i-1], d[i])*(1-k[i-1])*k[i]

                                       + dis(c[i-1], c[i])*(1-k[i-1])*(1-k[i]);

初始化：i行依赖i-1行和j-1列，i=1比较特殊（不能通过距离计算），初始化第1行和第0列

① 第1行：由于只有一个时间段，无论换不换值都是0，注意：d(1, 0, 1) = INF（这个情况不可能）。

② 第0列(j = 0, i > 1)， a. dp(i, 0, 1) = INF(没有申请次数，不可能申请) b. dp(i, 0, 0) = dp(i-1, 0, 0) + dis(c[i-1], c[i]);

#include <iostream>
#include <cstdio>
#include <cstring>
#include <sstream>
#include <string>
using namespace std;
const int V=305,N=2005,M=2005,INF=0x3f3f3f3f;
int n,m,v,e,dis[V][V],c[N],d[N];
double k[N],dp[N][M][2];
int main(){
    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]);
    memset(dis,0x3f,sizeof(dis));
    for(int i=1;i<=v;i++) dis[i][i]=0;
    int a,b,w;
    for(int i=1;i<=e;i++){
        scanf("%d%d%d",&a,&b,&w);
        dis[a][b]=dis[b][a]=min(dis[a][b],w);
    }
    for(int x=1;x<=v;x++)
        for(int i=1;i<=v;i++)
            for(int j=1;j<=v;j++)
                dis[i][j]=min(dis[i][j],dis[i][x]+dis[x][j]);
    dp[1][0][1]=INF;
    for(int i=2;i<=n;i++){
        dp[i][0][1]=INF,dp[i][0][0]=dp[i-1][0][0]+dis[c[i-1]][c[i]];
    }
    for(int i=2;i<=n;i++)
    for(int j=1;j<=m;j++){
        dp[i][j][0]=min(dp[i-1][j][0]+dis[c[i-1]][c[i]],
            dp[i-1][j][1]+dis[d[i-1]][c[i]]*k[i-1]+dis[c[i-1]][c[i]]*(1-k[i-1]));
        dp[i][j][1]=min(dp[i-1][j-1][0]+dis[c[i-1]][d[i]]*k[i]+dis[c[i-1]][c[i]]*(1-k[i]),
                        dp[i-1][j-1][1]+dis[d[i-1]][d[i]]*k[i-1]*k[i]
                                       +dis[d[i-1]][c[i]]*k[i-1]*(1-k[i])
                                       +dis[c[i-1]][d[i]]*(1-k[i-1])*k[i]
                                       +dis[c[i-1]][c[i]]*(1-k[i-1])*(1-k[i]));
    }
    double ans=min(dp[n][m][0],dp[n][m][1]);
    printf("%.2lf",(int)(ans*100+0.5)/100.0);
    return 0;
}