Damaged Bicycle(期望 + 状压DP)

题面

思路

假设当前单车是now，前一个单车是pre；

• 如果前一辆单车是好的，那么我们直接骑走；
• 如果前一辆单车是坏的，那么我们有两种决策；
  1.直接摆烂，走路去学校
  2.寻找当前的单车(当前的单车也有好也有坏的情况，按这个思路循环即可全部求解)

$f(s,i)$表示已经遍历过的自行车集合为$s$，最后一次停留在$i$点的最小时间期望值；

然后按上述思路进行DP即可；

---

因为我们只涉及3个点，起点、自行车、终点，我们不需要每个点都跑最短路，只需要在每个自行车点跑最短路即可；

Code

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <unordered_map>
#include <vector>
#include <utility>
#include <queue>

using namespace std;

typedef long long ll;

const int N = 1e5 + 10,M = 1 << 20,K = 20,INF = 1e9;

int t,r,n,m,k;

int a[N],p[N];

typedef pair<int,int> pii;

priority_queue<pii,vector<pii>,greater<pii>> pq;

int dist[K][N];//dist(k,i)表示从第k个单车到第i个点的最短路
double f[M][K];//f(s,i)表示集合s中的车都是坏的，最后停留在第i个单车
bool vis[N];

vector<pii> G[N];

void dij(int start,int dist[]){
    for(int i=1;i<=n;++i) dist[i] = INF,vis[i] = 0;
    start = a[start];
    dist[start] = 0;
    pq.push({0,start});
    while(!pq.empty()){
        int u = pq.top().second;
        pq.pop();
        if(vis[u]) continue;
        vis[u] = 1;
        for(auto to : G[u]){
            int v = to.first,w = to.second;
            if(dist[v] > dist[u] + w){
                dist[v] = dist[u] + w;
                pq.push({dist[v],v});
            }
        }
    }
}
double fp[N];//概率
void solve(){
    cin >> t >> r;
    cin >> n >> m;
    for(int i=1;i<=m;++i){
        int u,v,w;
        cin >> u >> v >> w;
        G[u].push_back({v,w});
        G[v].push_back({u,w});
    }
    cin >> k;
    for(int i=1;i<=k;++i){
        cin >> a[i] >> p[i];
        fp[i] = 1.0 * p[i] / 100;
    }
    a[0] = 1,p[0] = 100;//构建一个虚无单车在1号点,且损坏
    for(int i=0;i<=k;++i){
        dij(i,dist[i]);
    }
    if(dist[0][n] == INF){
        cout << -1 << '\n';
        return;
    }
    memset(f,0x42,sizeof f);
    for(int s=(1<<k)-1;s>=0;--s){//注意拓扑序，这里需要逆序
        for(int pre=1;pre<=k;++pre){//上一次
            if((s>>(pre-1))&1){
                //好的直接骑走，坏的走路
                f[s][pre] = (1-fp[pre])*1.0*dist[pre][n]/r + fp[pre]*1.0*dist[pre][n]/t;
                for(int now=1;now<=k;++now){//当前
                    if((s>>(now-1))&1) continue;
                    f[s][pre] = min(f[s][pre],
                        //好的上次就骑走了，否则交给当前点now
                        (1-fp[pre])*1.0*dist[pre][n]/r
                        + fp[pre]*(1.0*dist[pre][a[now]]/t + f[s|(1<<(now-1))][now])
                    );
                }
            }
        }
    }
    double ans = 1.0*dist[0][n] / t;//走路
    //寻找第一辆单车
    for(int x=1;x<=k;++x){
        ans = min(ans,1.0*dist[0][a[x]]/t + f[1<<(x-1)][x]);
    }
    printf("%.6f\n",ans);
}

signed main(){
   // std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
    solve();
    return 0;
}