[Noi2005]聪聪和可可

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。

第一道概率dp的题，首先要对每一个点bfs一下， 预处理出从i到j的最短路上，i下一步会走到的点p[i][j]；

设dp[i][j]表示聪聪在i，可可在j时聪聪可以吃到可可平均要走的次数

如果p[i][j] == j || p[ p[i][j] ][j] == j,则dp[i][j] = 1,

如果i == j  dp[i][j] = 0;

其他情况： 令u = p[ p[i][j] ][j]

dp[i][j] = ((dp[u][j] + 1)+ sigma(dp[u][k] (k与点j相连) + 1)) / (deg[j] + 1)

deg[j] 是点j的度数

#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
const int N = 1010;
int n, m;
int p[N][N];
int dist[N];
double dp[N][N];
int deg[N];
int head[N];
int tot;

struct node
{
	int next;
	int to;
}edge[N << 2];

void addedge(int from, int to)
{
	edge[tot].to = to;
	edge[tot].next = head[from];
	head[from] = tot++;
}

void short_distance()
{
	queue <int> qu;
	for (int i = 1; i <= n; ++i)
	{
		while (!qu.empty())
		{
			qu.pop();
		}
		memset (dist, 0x3f3f3f3f, sizeof(dist));
		dist[i] = 0;
		qu.push(i);
		p[i][i] = i;
		while (!qu.empty())
		{
			int u = qu.front();
			qu.pop();
			for (int j = head[u]; ~j; j = edge[j].next)
			{
				int v = edge[j].to;
				if (dist[v] > dist[u] + 1 ||(u < p[v][i] && dist[v] == dist[u] + 1))
				{
					p[v][i] = u;
					dist[v] = dist[u] + 1;
					qu.push(v);
				}
			}
		}
	}
}

double dfs(int i, int j)
{
	if (i == j)
	{
		return dp[i][j] = 0;
	}
	if (p[i][j] == j || p[ p[i][j] ][j] == j)
	{
		return dp[i][j] = 1;
	}
	if (dp[i][j] != -1)
	{
		return dp[i][j];
	}
	double cur = 0;
	int u = p[ p[i][j] ][j];
	cur = dfs(u, j) + 1; //可可留在原地
	for (int k = head[j]; ~k; k = edge[k].next)
	{
		cur += dfs(u, edge[k].to) + 1;
	}
	cur /= (deg[j] + 1);
	return dp[i][j] = cur;
}

int main()
{
	int s, e;
	while (~scanf("%d%d", &n, &m))
	{
		scanf("%d%d", &s, &e);
		int u, v;
		memset (head, -1, sizeof(head));
		memset (deg, 0, sizeof(deg));
		tot = 0;
		for (int i = 1; i <= m; ++i)
		{
			scanf("%d%d", &u, &v);
			addedge(u, v);
			addedge(v, u);
			deg[u]++;
			deg[v]++;
		}
		for (int i = 1; i <= n; ++i)
		{
			dp[i][i] = 0;
			for (int j = 1; j <= n; ++j)
			{
				if (i == j)
				{
					continue;
				}
				dp[i][j] = -1;
			}
		}
		short_distance();
		dfs(s, e);
		printf("%.3f\n", dp[s][e]);
	}
	return 0;
}