HDU 4035 Maze 期望dp

题意：这是一个树形的迷宫，一个人从1节点开始走，他会任意选择一条边走，然后每到一个节点i，有Ki的概率被kill，然后从1节点继续开始，有Ei的概率逃出这个迷宫。问逃出迷宫的期望

分析；这个题和上一题的丢骰子的题很像；
dp[i]:i节点逃出去的期望是多少。然后最后的答案就是dp[1]

如果i是叶子节点
dp[i]=K[i]dp[1]+E[i]*0+(dp[father]+1)(1-K[i]-E[i]);
如果i不是叶子节点
dp[i]=K[i]dp[1]+E[i]*0+(dp[father]+1+$\sum$dp[son])(1-K[i]-E[i])

然后设dp[i]=A[i]*dp[1]+B[i]*dp[father]+C[i]
为什么要这么设，因为在求当前i的时候，dp[1]和dp[father]是不知道的，所以就把它们设为未知数

然后就可以解出来A[i],B[i],C[i]

因为dp[1]=A[1]*dp[1]+B[1]*0+C[1];
dp[1]=C[1]/(1-A[1])

当分母趋近于0的时候，时间是无限大的，然后就是impossible

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <vector>

using namespace std;
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
const int maxn = 1e4+10;
int vis[maxn];
double A[maxn],B[maxn],C[maxn],K[maxn],E[maxn];
vector<int> v[maxn];
bool dfs(int u)
{
    vis[u]=1;
    double temp=0,t=1.0-K[u]-E[u],m=v[u].size();
    for(int i=0;i<v[u].size();i++)
    {
        int to=v[u][i];
        if(vis[to]) continue;
        if(!dfs(to)) return false;
        A[u]+=A[to];
        temp+=B[to];
        C[u]+=C[to];
    }
    A[u]=t/m*A[u];temp=t/m*temp;C[u]=t/m*C[u];
    A[u]+=K[u];C[u]+=t; B[u]+=t/m;
    if(fabs(1-temp)<1e-9) return false;
    A[u]/=(1-temp);
    B[u]/=(1-temp);
    C[u]/=(1-temp);
    return true;
}
int main()
{
    int T,case1=1;
    scanf("%d",&T);
    while(T--)
    {
        mem(vis,0);mem(E,0);mem(K,0);mem(A,0);mem(B,0);mem(C,0);
        for(int i=0;i<maxn;i++) v[i].clear();
        int n;
        scanf("%d",&n);
        for(int i=0;i<n-1;i++)
        {
            int x,y;
            scanf("%d %d",&x,&y);
            v[x].push_back(y);
            v[y].push_back(x);
        }
        for(int i=1;i<=n;i++)
        {
            scanf("%lf %lf",&K[i],&E[i]);
            K[i]=K[i]/100.0;E[i]=E[i]/100.0;
        }
        vis[1]=1;
        printf("Case %d: ",case1++);
        if(dfs(1)&&fabs(1-A[1])>1e-9){
            printf("%.6f\n",C[1]/(1-A[1]));
        }
        else printf("impossible\n");
    }
    return 0;
}