HDU 4035 Maze 树形概率DP 2011年成都网络赛E题

题目大意：

lxhgww 现在在一个树形图的点1上(此树形图共n个点，编号从1到n) 现在在第i点有 Ki%的概率被杀死回到点1， 有Ei%的概率逃出迷宫， 剩下的1 - Ki% - Ei%就是什么都没发生了，需要转到下一位置，其中K0 = E0 = 0， 现在给出树形图，定点数n <= 10000求lxhgww走出迷宫需要走多少次的期望

大致思路：

由于n <= 10000直接解线性方程组的复杂度不能接受，需要递推，递推公式及过程见代码

代码如下：
Result  :  Accepted     Memory  :  1588 KB     Time  :  203 ms

/*
* Author: Gatevin
* Created Time: 2014/12/2 17:57:35
* File Name: Asuna.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-10);//这里刚开始开eps = 1e-8 WA了...
typedef long long lint;

/*
* 很好的一道概率题， 首先不难发现如果用dp[i]表示从节点i到达目标状态需要的步数，有方程：
* dp[i] = ∑(dp[j] + 1)/G[i].size()*(1 - K[i] - E[i]) + K[i]*(dp[1] + 0) + E[i]*0;
* = ∑(dp[j] + 1)/G[i].size()*(1 - K[i] - E[i]) + K[i]*dp[1]
* 其中G[i]为与点i相邻的点组成的vector, K[i]为在i节点被杀死的概率, E[i]为出去的概率，j为与i相邻的点
* 这样对于dp[1~n]一共有n个方程，可见一定是可解的，但是由于n的范围太大，需要递推求解
* 这里由于dp[1]为起点，将其视作整棵树的根节点，那么原来的方程需要写为
* dp[i] = ∑dp[son[i]]/G[i].size()*(1 - K[i] - E[i]) + dp[father[i]]/G[i].size()*(1 - K[i] - E[i]) + K[i]*dp[1] + (1 - K[i] - E[i])
* 其中son[i]是i的子节点,father[i]是i的父节点,那么对于叶子节点
* dp[i] = dp[father[i]]*(1 - K[i] - E[i]) + K[i]*dp[1] + 1 - K[i] - E[i]
* (因为对于叶子节点，没有继续下去的儿子，且G[i].size() = 1)
* 那么可以发现从叶子节点往上看，每一个儿子节点都可以表示成A*dp[1] + B*dp[father] + C的形式，那么对于一个点的所有子节点
* 不难发现其father是一样的，并且带入当前的father节点可以算出相应的father节点满足的关系那么从叶节点开始后序遍历这棵树即可最终递推出dp[1]
* 并且dp[1] = ∑dp[son[1]]/G[1].size()*(1 - 0 - 0) + 0*dp[1] + 1 - 0 - 0
* 于是dp[1]便可以解出
* 这里我的代码是将每个节点的A,B,C参数用dp1表示多少倍dp[1]， dpfa表示多少倍其父节点，cons表示常数项
* 递推求解即可
*/

double K[10010], E[10010];
vector <int> G[10010];
bool vis[10010];
int father[10010];
int n, x, y;

struct Node
{
double dp1, dpfa, cons;
Node(double a = 0, double b = 0, double c = 0)
{
dp1 = a; dpfa = b; cons = c;
}
};

Node operator + (Node n1, Node n2)
{
return Node(n1.dp1 + n2.dp1, n1.dpfa + n2.dpfa, n1.cons + n2.cons);
}

void dfs(int now)
{
vis[now] = 1;
for(unsigned int i = 0; i < G[now].size(); i++)
{
if(!vis[G[now][i]])
{
father[G[now][i]] = now;
dfs(G[now][i]);
}
}
return;
}

Node solve(int now)
{
if(G[now].size() == 1) return Node(K[now], 1 - K[now] - E[now], 1 - K[now] - E[now]);
Node ret;
for(unsigned int i = 0; i < G[now].size(); i++)
if(G[now][i] != father[now])
ret = ret + solve(G[now][i]);
double tmp = (1 - ret.dpfa/G[now].size()*(1 - K[now] - E[now]));
ret.dp1 /= G[now].size(); ret.dp1 *= (1 - K[now] - E[now]); ret.dp1 += K[now];
ret.dpfa = (1 - K[now] - E[now])/G[now].size();
ret.cons /= G[now].size(); ret.cons *= (1 - K[now] - E[now]); ret.cons += 1 - K[now] - E[now];
return Node(ret.dp1/tmp, ret.dpfa/tmp, ret.cons/tmp);
}

int main()
{
int t;
scanf("%d", &t);
for(int cas = 1; cas <= t; cas++)
{
scanf("%d", &n);
for(int i = 1; i <= n; i++) G[i].clear();
for(int i = 1; i <= n - 1; i++)
{
scanf("%d %d", &x, &y);
G[x].push_back(y);
G[y].push_back(x);
}
for(int i = 1; i <= n; i++)
{
scanf("%d %d", &x, &y);
K[i] = x*1.0/100; E[i] = y*1.0/100;
}
memset(vis, 0, sizeof(vis));
dfs(1);
Node one;
for(unsigned int i = 0; i < G[1].size(); i++)
one = one + solve(G[1][i]);
if(G[1].size() - one.dp1 - one.dpfa < eps)
{
printf("Case %d: impossible\n", cas);
continue;
}
double ans = (one.cons + G[1].size())/(G[1].size() - one.dp1 - one.dpfa);
if(ans < eps) printf("Case %d: impossible\n", cas);
else printf("Case %d: %.6f\n", cas, ans);
}
return 0;
}