2021ccpc 哈尔滨 G 状压dp+期望dp

题意：

有$n$个地方，被$m$条路连接着。某个人走路和汽车的速度分别是$t,r(m/s)$，其中$t\le r$。有$k(k\le 18)$个地方有单车，但每个地方的单车有$\frac{p_i}{100}$的概率是坏的。现在这个人要从$1$到$n$去，求出一种方案，使得期望总时间最小，输出这个期望总时间

Solution：

显然我们需要考虑要不要去找单车，并且有关期望，考虑期望dp，再考虑如何遍历单车，看到$k\le 18$，考虑状压dp，和吃奶酪那题类似，定义$dp[i][s]$为走过集合为$s$，目前停留在$i$的某种属性如何，由于要考虑期望，不妨设$dp[i][s]$为检查单车集合为$s$，目前停留在$i$，到$n$的期望时间。

期望dp考虑决策，对每个$s,i$，我们有如下两种决策：

（1）当前位置的单车没坏，骑上直接润

（2）当前位置的单车坏了，接下来又有两种可能，再去找单车，或者直接走路润

于是在每个位置，有这样的事件

（单车没坏，骑上出发），（单车坏了，不找了走路去），（单车坏了，再去找单车）

而事件组合则存在两个

（单车没坏，骑上出发）+（单车坏了，不找了走路去）

（单车没坏，骑上出发）+（单车坏了，再去找单车）

那么期望=每个事件的值×概率，接下来推导转移方程

显然全部单车都找过的时候不存在3，是个边界情况，于是

for(int i=1;i<=k;i++) dp[i][(1<<k)-1]=p[i]/100*dis(a[i],n)/t+(100-p[i])/100*dis(a[i],n/r)

并且由于转移方程为：

继续去找单车：

$$
dp[i][s]=\frac{p_{i}}{100}(dp[j][s|1<<(j-1)]+dis(a[i],a[j])/t)+(1-\frac{p_{i}}{100})dis(a[i],n)/r\

$$

不找了直接润：

$$dp[i][s]=\frac{p_i}{100}dis(a[i],n)/t+(1-\frac{p_i}{100})dis(a[i],n)/r$$

每次都从比自己大的$s$转移而来，于是需要倒推

其中$dis(x,y)$都只有关于$1,a[1],a[2],a[3],....,a[k],n$这些点，对$1,a[1],a[2],....,a[k]$分别做一共$k+1$次$dijkstra$就可以预处理出来

// #include<bits/stdc++.h>
#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;

using ll=long long;
const int N=200005,inf=0x3fffffff;
const long long INF=0x3f3f3f3f3f3f,mod=998244353;

struct way
{
	int to,next,w;
}edge[N<<1];
int cnt,head[N];

void add(int u,int v,int w)
{
	edge[++cnt].to=v;
	edge[cnt].w=w;
	edge[cnt].next=head[u];
	head[u]=cnt;
}

int n;
bool vis[N];

void dijkstra(int *dis,int s)
{
	for(int i=1;i<=n;i++) dis[i]=inf,vis[i]=false;
	priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>q;
	q.push({dis[s]=0,s});
	while(!q.empty())
	{
		int u=q.top().second; q.pop();
		if(vis[u]) continue;
		vis[u]=true;
		for(int i=head[u];i;i=edge[i].next)
		{
			int v=edge[i].to,w=edge[i].w;
			if(dis[u]+w<dis[v]) q.push({dis[v]=dis[u]+w,v});
		}
	}
}

int m,t,r,k,a[20],p[20],dis[20][N];
double dp[20][1<<18];

int main()
{
	ios::sync_with_stdio(false);
	cin>>t>>r>>n>>m;
	while(m--)
	{
		int u,v,w; cin>>u>>v>>w;
		add(u,v,w); add(v,u,w);
	}
	cin>>k;
	for(int i=1;i<=k;i++)
	{
		cin>>a[i]>>p[i];
		dijkstra(dis[i],a[i]);
	}
	dijkstra(dis[0],n);
	if(dis[0][1]==inf)
	{
		printf("-1");
		return 0;
	}
	for(int i=0;i<=18;i++)
		for(int s=0;s<(1<<18);s++) dp[i][s]=inf;
	for(int i=1;i<=k;i++) dp[i][(1<<k)-1]=1.0*(100-p[i])/100*dis[0][a[i]]/r+1.0*p[i]/100*dis[0][a[i]]/t;
	for(int s=(1<<k)-1;s>=0;s--)
	{
		for(int i=1;i<=k;i++)
		{
			if((s>>(i-1))&1)
			{
				dp[i][s]=1.0*(100-p[i])/100*dis[0][a[i]]/r+1.0*p[i]/100*dis[0][a[i]]/t;
				for(int j=1;j<=k;j++)
				{
					if((s>>(j-1))&1) continue;
					dp[i][s]=min(dp[i][s],1.0*p[i]/100*(dp[j][s|(1<<(j-1))]+1.0*dis[i][a[j]]/t)+1.0*(100-p[i])/100*dis[i][n]/r);
				}
			}
		}
	}
	double ans=1.0*dis[0][1]/t;
	for(int i=1;i<=k;i++) ans=min(ans,1.0*dis[i][1]/t+1.0*dp[i][1<<(i-1)]);
	printf("%.6lf",ans);
	return 0;
}