HDU 4035 Maze

非常nice的一个概率dp，此题要求的是走出去的步数的期望，首先我们要把问题转化为从任意点出发，到 1 点需要步数期望。于是问题就转化为到 1 点的步数的期望了。然后我们就可以得到每一个点的期望公式：

E[i]= ki*E[1] + (1-ki-ei)/m*( E[father[i]]+1 + ∑( E[child[i]]+1 ) )= ki*E[1] + (1-ki-ei)/m*E[father[i]] + (1-ki-ei)/m*∑(E[child[i]]) + (1-ki-ei)-----（1）。

特别的对于叶子节点有：

E[i]= ki*E[1] + (1-ki-ei)/m*( E[father[i]]+1 )= ki*E[1] + (1-ki-ei)/m*E[father[i]]；

对于每个节点 设：E[i] = Ai*E[1] + Bi*E[father[i]] + Ci; 然后对式（1）进行扩展，把E[child[i]]扩展下去，就可得到关系式：

Ai = (ki+(1-ki-ei)/m*∑Aj) / (1 - (1-ki-ei)/m*∑Bj);
Bi = (1-ki-ei)/m / (1 - (1-ki-ei)/m*∑Bj);
Ci = ( (1-ki-ei)+(1-ki-ei)/m*∑Cj ) / (1 - (1-ki-ei)/m*∑Bj);

其中有叶子节点：

Ai = ki;
Bi = 1 - ki - ei;
Ci = 1 - ki - ei;

然后求出E[1]即为答案。

思路是看了jack ge 大牛的博客：http://www.cnblogs.com/jackge/archive/2013/05/21/3091893.html才理解的，大牛分析的很详细，想详细学习的可以去看这个大牛的博客~~~

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define CLR(a, b) memset(a, b, sizeof(a))

using namespace std;

const int N = 10001;

struct Edge
{
    int u, v;
}E[N << 1];

int fir[N], next[N << 1], tot;
double k[N], e[N];
double a[N], b[N], c[N];

void Add_Edge(int u, int v)
{
    E[tot].u = u, E[tot].v = v;
    next[tot] = fir[u], fir[u] = tot ++;
}

bool dfs(int u, int fa)
{
    int v, i, j, flag = 0, esum = 1;
    double asum = 0, bsum = 0, csum = 0, p = 1 - k[u] - e[u], tmp;
    if(fa == -1) esum = 0;
    for(i = fir[u]; ~i; i = next[i])
    {
        v = E[i].v;
        if(v != fa)
        {
            flag = 1;
            if(!dfs(v, u)) return 0;
            asum += a[v];bsum += b[v]; csum += c[v];
            esum ++;
        }
    }
    if(flag)
    {
        tmp = 1 - p / esum * bsum;
        if(fabs(tmp) < 1e-10) return 0;
        a[u] = (k[u] + p / esum * asum) / tmp;
        b[u] = p / esum / tmp;
        c[u] = (p + p / esum * csum) / tmp;
    }
    else
    {
        a[u] = k[u];b[u] = p;c[u] = p;
    }
    return 1;
}

int main()
{
    //freopen("input.txt","r",stdin);
    int n, t, cas = 1, i, j, u, v, kk, ee;
    scanf("%d", &t);
    while(t --)
    {
        scanf("%d", &n);
        tot=0;CLR(fir, -1);
        for(i = 1; i < n; i ++)
        {
            scanf("%d%d", &u, &v);
            Add_Edge(u, v);
            Add_Edge(v, u);
        }
        for(i = 1; i <= n; i ++)
        {
            scanf("%d%d", &kk, &ee);
            k[i] = kk / 100.0;e[i] = ee / 100.0;
        }
        if(!dfs(1, -1) || abs(a[1] - 1) < 1e-10)printf("Case %d: impossible\n", cas ++);
        else printf("Case %d: %.6lf\n", cas ++, c[1] / (1 - a[1]));
    }
}