借助树的概率dp(期望)+数学-好题-hdu-4035-Maze

题目链接：

http://acm.hdu.edu.cn/showproblem.php?pid=4035

题目意思：

有n个房间，有n-1条通道连接这n个房间（每两个房间之间有且只有一条路，所以实际上就是一棵树），在每个房间中，有三种选择要么被杀则回到第一个房间，概率为ki,要么从出口逃离概率为ei,要么通过通道到达其他的房间。

解题思路：

好题。

状态转移方程很好想，但是求的时候有技巧，不能直接用高斯消元来求（n有10000）肯定会超时。发现知，此题是在一棵树上转移，所以可以借助树的特点，分成两部分儿子和父亲，抽象出系数，然后从叶子节点向上求出父亲节点。

以下文字选自http://blog.csdn.net/morgan_xww/article/details/6776947

设 E[i]表示在结点i处，要走出迷宫所要走的边数的期望。E[1]即为所求。



叶子结点：

E[i] = ki*E[1] + ei*0 + (1-ki-ei)*(E[father[i]] + 1);

= ki*E[1] + (1-ki-ei)*E[father[i]] + (1-ki-ei);



非叶子结点：（m为与结点相连的边数）

E[i] = ki*E[1] + ei*0 + (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);



设对每个结点：E[i] = Ai*E[1] + Bi*E[father[i]] + Ci;



对于非叶子结点i，设j为i的孩子结点，则

∑(E[child[i]]) = ∑E[j]

= ∑(Aj*E[1] + Bj*E[father[j]] + Cj)

= ∑(Aj*E[1] + Bj*E[i] + Cj)

带入上面的式子得

(1 - (1-ki-ei)/m*∑Bj)*E[i] = (ki+(1-ki-ei)/m*∑Aj)*E[1] + (1-ki-ei)/m*E[father[i]] + (1-ki-ei) + (1-ki-ei)/m*∑Cj;

由此可得

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;



从叶子结点开始，直到算出 A1,B1,C1;



E[1] = A1*E[1] + B1*0 + C1;

所以

E[1] = C1 / (1 - A1);

若 A1趋近于1则无解...

代码：

#include<iostream>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<algorithm>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<ctime>
#define eps 1e-9
#define INF 0x3fffffff
#define PI acos(-1.0)
#define ll __int64
#define lson l,m,(rt<<1)
#define rson m+1,r,(rt<<1)|1
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;

#define Maxn 10100

int deg[Maxn],cnt,n;
double A[Maxn],B[Maxn],C[Maxn]; //分别表示系数
double k[Maxn],e[Maxn];//表示被杀和逃离概率

struct Edge
{
    int v;
    struct Edge * next;
}edge[Maxn<<1],*head[Maxn<<1];

void add(int a,int b)
{
    ++cnt;
    deg[a]++; //度数
    edge[cnt].v=b,edge[cnt].next=head[a];
    head[a]=&edge[cnt];
}
void dfs(int cur,int pre)
{
    struct Edge * p=head[cur];
    bool flag=true;
    double suma=0,sumb=0,sumc=0;

    while(p)
    {
        int v=p->v;
        if(v!=pre)
        {
            flag=false;  //不是叶子节点
            dfs(v,cur);suma+=A[v];sumb+=B[v];sumc+=C[v];
        } //求出儿子节点的各和
        p=p->next;
    }
    if(flag) //叶子节点
    {
        double t=1-k[cur]-e[cur];
        A[cur]=k[cur],B[cur]=t,C[cur]=t;
        return ;
    }//非叶子节点
    double temp=(1-k[cur]-e[cur])/deg[cur];
    double tt=1-temp*sumb;

    A[cur]=(k[cur]+temp*suma)/tt;
    B[cur]=temp/tt;
    C[cur]=(temp*sumc+(1-k[cur]-e[cur]))/tt;
    return ;
}

int main()
{
    int t;

    scanf("%d",&t);
    for(int ca=1;ca<=t;ca++)
    {
        scanf("%d",&n);
        memset(head,NULL,sizeof(head));
        memset(deg,0,sizeof(deg));
        cnt=0;

        for(int i=1;i<n;i++)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            add(a,b),add(b,a);
        }
        for(int i=1;i<=n;i++)
        {
            double a,b;
            scanf("%lf%lf",&a,&b);
            k[i]=a/100.0,e[i]=b/100.0;
        }
        dfs(1,-1);
        printf("Case %d: ",ca);
        if(fabs(1-A[1])<eps) //这里卡精度
            printf("impossible\n");
        else
            printf("%.5f\n",C[1]/(1.0-A[1]));
    }
   return 0;
}