BZOJ4899 记忆的轮廓

最新推荐文章于 2020-04-24 20:38:42 发布

neither_nor

最新推荐文章于 2020-04-24 20:38:42 发布

阅读量862

点赞数

分类专栏： BZOJ DP、递推

本文链接：https://blog.csdn.net/neither_nor/article/details/72723791

版权

BZOJ 同时被 2 个专栏收录

382 篇文章 1 订阅

订阅专栏

DP、递推

84 篇文章 1 订阅

订阅专栏

该博客探讨了一种问题，在错误路线中如何通过存档策略优化期望步数。文章首先定义了g[i]表示在位置i误入歧途后的期望读档距离，然后计算了不存档从i到j的期望步数dis[i][j]。博主提出使用动态规划方法，f[i][j]表示达到i并存档j次的最优期望步数，但由于状态空间呈指数增长，直接转移会导致高复杂度。通过观察每个点的度数至少为2，博主推测相邻存档点间距离较短，从而将复杂度优化至n^2级别。

摘要由CSDN通过智能技术生成

我们知道只要误入歧途你就再也不能回到正轨了，只能走到错误叶子然后读档

那么我们先求出g[i]代表在i误入歧途之后期望要走多远才会读档

然后求出dis[i][j]代表在i存档之后从i走到j中间不存档期望要走多少步

这个n^2随便求

那么我们可以DP，f[i][j]表示从起点走到i，并在i存档，当前一共已经存档j次的最优期望步数

直接转移显然是n^2p的

我们发现题目限制了每个点的度数>=2

那么根据求dis的式子我们可以看出在i固定的情况下，dis是一个指数增长的函数，而误入歧途对答案的影响只是常数级的，那么我们猜测转移的时候相邻两个存档点的距离不会太长，大概应该是n/p级别的，然后复杂度就变成n^2了

#include<iostream>
#include<cstring>
#include<ctime>
#include<cmath>
#include<algorithm>
#include<iomanip>
#include<cstdlib>
#include<cstdio>
#include<map>
#include<bitset>
#include<set>
#include<stack>
#include<vector>
#include<queue>
using namespace std;
#define MAXN 1510
#define MAXM 1010
#define ll long long
#define eps 1e-8
#define MOD 1000000007
#define INF 1000000000
char xch,xB[1<<15],*xS=xB,*xTT=xB;
#define getc() (xS==xTT&&(xTT=(xS=xB)+fread(xB,1,1<<15,stdin),xS==xTT)?0:*xS++)
inline int read()
{
	int x=0,f=1;char ch=getc();
	while(ch<'0'|ch>'9'){if(ch=='-')f=-1;ch=getc();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getc();}
	return x*f;
}
struct vec{
	int to;
	int fro;
};
vec mp[MAXN];
int tai[MAXN],cnt;
int n,m,p;
double g[MAXN];
int d[MAXN];
double f[MAXN][MAXN],h[MAXN][MAXN];
inline void be(int x,int y){
	mp[++cnt].to=y;
	mp[cnt].fro=tai[x];
	tai[x]=cnt;
}
void dfs(int x){
	int i,y;
	g[x]=1;
	for(i=tai[x];i;i=mp[i].fro){
		y=mp[i].to;
		dfs(y);
		g[x]+=1.*g[y]/d[x];
	}
}
int main(){
	int i,j,x,y,k;
	int tmp;
	tmp=read();
	while(tmp--){
		memset(tai,0,sizeof(tai));
		memset(d,0,sizeof(d));
		cnt=0;
		n=read();
		m=read();
		p=read();
		for(i=1;i<=m-n;i++){
			x=read();
			y=read();
			d[x]++;
			be(x,y);
		}
		for(i=1;i<=n;i++){
			dfs(i);
		}
		for(i=1;i<=n;i++){
			for(j=i+1;j<=n;j++){
				f[i][j]=(f[i][j-1]+1./(d[j-1]+1)+1.*d[j-1]/(d[j-1]+1)*g[j-1])*(d[j-1]+1);
			}
		}
		for(i=1;i<=n;i++){
			for(j=1;j<=p;j++){
				h[i][j]=1e100;
			}
		}
		int lim=(n+p-1)/p+1;
		h[1][1]=0;
		for(i=1;i<=n;i++){
			for(j=1;j<p;j++){
				for(k=i+1;k<=i+lim&&k<=n;k++){
					h[k][j+1]=min(h[k][j+1],h[i][j]+f[i][k]);
				}
			}
		}
		printf("%.4lf\n",h[n][p]);
	}
	return 0;
}

/*

*/