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;
}