[BZOJ]1415 [NOI2005] 聪聪与可可 期望 + 记忆化搜索

1415: [Noi2005]聪聪和可可

Time Limit: 10 Sec   Memory Limit: 162 MB
Submit: 1890   Solved: 1103
[ Submit][ Status][ Discuss]

Description

Input

数据的第1行为两个整数N和E，以空格分隔，分别表示森林中的景点数和连接相邻景点的路的条数。 第2行包含两个整数C和M，以空格分隔，分别表示初始时聪聪和可可所在的景点的编号。 接下来E行，每行两个整数，第i+2行的两个整数Ai和Bi表示景点Ai和景点Bi之间有一条路。 所有的路都是无向的，即：如果能从A走到B，就可以从B走到A。 输入保证任何两个景点之间不会有多于一条路直接相连，且聪聪和可可之间必有路直接或间接的相连。

Output

输出1个实数，四舍五入保留三位小数，表示平均多少个时间单位后聪聪会把可可吃掉。

Sample Input

【输入样例1】
4 3
1 4
1 2
2 3
3 4
【输入样例2】
9 9
9 3
1 2
2 3
3 4
4 5
3 6
4 6
4 7
7 8
8 9

Sample Output

【输出样例1】
1.500
【输出样例2】
2.167

HINT

【样例说明1】
开始时，聪聪和可可分别在景点1和景点4。
第一个时刻，聪聪先走，她向更靠近可可(景点4)的景点走动，走到景点2，然后走到景点3；假定忽略走路所花时间。
可可后走，有两种可能：
第一种是走到景点3，这样聪聪和可可到达同一个景点，可可被吃掉，步数为1，概率为 。
第二种是停在景点4，不被吃掉。概率为 。
到第二个时刻，聪聪向更靠近可可(景点4)的景点走动，只需要走一步即和可可在同一景点。因此这种情况下聪聪会在两步吃掉可可。
所以平均的步数是1* +2* =1.5步。


对于所有的数据，1≤N,E≤1000。
对于50%的数据，1≤N≤50。

Source

[ Submit][ Status][ Discuss] 

HOME Back

      期望可以套好多东西...

看着只有1000个点1000条边， 感觉暴力都可以过了...事实上就是爆搜模拟， 加了个记忆化就可以过. dfs只用代入x， y两个参数， 一个代表聪聪的位置， 一个代表可可的位置， 每次模拟即可. 注意聪聪快接近可可时要特判， 因为是聪聪先走两步， 所以距离两步以内必追. 聪聪的方向直接每个点spfa， 求出一个方向数组cm, cm[x][y]表示聪聪在x可可在y时聪聪下一步要去哪里. 看看代码很清晰. 期望都是普通的期望了， dp[x][y]表示聪聪在x可可在y时期望还要走的时间. 由期望的线性性， 当前dp[x][y]直接由其他点的期望乘上概率转移过来即可， 然后加1(普通的期望公式).

#include<stdio.h>
#include<queue>
#include<cstring>
#define lossa(a) memset(a, -1, sizeof(a))
#define clear(a) memset(a, 0, sizeof(a))
#define fufil(a) memset(a, 120, sizeof(a))
using namespace std;
const int maxn = 1005;
const double eps = 1e-10;
queue<int> q;
bool vis[maxn];
double dp[maxn][maxn];
int d[maxn], from[maxn], h[maxn], dis[maxn], cm[maxn][maxn], num, n, m, s, t;
inline const int read(){
	register int x = 0;
	register char ch = getchar();
	while(ch < '0' || ch > '9') ch = getchar();
	while(ch >= '0' && ch <= '9') x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
	return x;
}
struct edge{ int nxt, v;}e[maxn * 2];
inline void add(int u, int v){
	d[u]++, e[++num].v = v, e[num].nxt = h[u], h[u] = num;
	d[v]++, e[++num].v = u, e[num].nxt = h[v], h[v] = num;
}
inline void SPFA(int st){
	fufil(dis), clear(vis), clear(from);
	q.push(st), dis[st] = 0, vis[st] = true;
	while(!q.empty()){
		int u = q.front();
		q.pop(), vis[u] = false;
		for(int i = h[u]; i; i = e[i].nxt){
			int v = e[i].v;
			if(dis[v] > dis[u] + 1 || dis[v] == dis[u] + 1 && u < from[v]){
				dis[v] = dis[u] + 1, from[v] = u;
				if(!vis[v]) q.push(v), vis[v] = true;
			}
		}
	}
	for(int i = 1; i <= n; ++i)
		if(i != st) cm[i][st] = from[i];
}
double dfs(int x, int y){
	if(x == y) return dp[x][y] = 0;
	if(cm[x][y] == y) return dp[x][y] = 1;  // 聪聪可以走两步， 所以只差一步的话一定追的上
	if(cm[cm[x][y]][y] == y) return dp[x][y] = 1;//只差两步， 但由于聪聪先走所以还是一定追的上 
	if(dp[x][y] > -eps) return dp[x][y];    //记忆化搜索
	dp[x][y] = 1;
	for(int i = h[y]; i; i = e[i].nxt)
		dp[x][y] += dfs(cm[cm[x][y]][y], e[i].v)/(d[y] + 1);
	dp[x][y] += dfs(cm[cm[x][y]][y], y)/(d[y] + 1);
	return dp[x][y]; 
}
int main(){
	n = read(), m = read(), s = read(), t = read();
	for(int i = 1; i <= m; ++i){
		int x = read(), y = read();
		add(x, y);
	}
	for(int i = 1; i <= n; ++i) SPFA(i);
	lossa(dp);
	printf("%.3f\n", dfs(s, t));
}