树形dp 求期望 HDU4035

特此声明：转载自 http://blog.youkuaiyun.com/morgan_xww/article/details/6776947   ，觉得比较好，就转载过来，如有版权问题，我立即删掉。

比赛时看题了，但是没有思路。比赛结束后这题总共通过20+，赛后看这个解题报告，由于博主说得太简洁，而我又是从来没有见过这种dp求数学期望的题，所以研究了好久都木有明白。只有搜索一下【dp求期望】的题目，从简单的开始入手，费了老大功夫，终于搞懂了，于是写下详细解题报告。

如果感觉这个题看不懂，也可以按照我的步骤来看：Poj 2096 --> Zoj 3329 --> Hdu 4035

[cpp]  view plain copy print ?

1. /** 
2.     dp求期望的题。 
3.     题意： 
4.     有n个房间，由n-1条隧道连通起来，实际上就形成了一棵树， 
5.     从结点1出发，开始走，在每个结点i都有3种可能： 
6.         1.被杀死，回到结点1处（概率为ki） 
7.         2.找到出口，走出迷宫 （概率为ei） 
8.         3.和该点相连有m条边，随机走一条 
9.     求：走出迷宫所要走的边数的期望值。 
10.      
11.     设 E[i]表示在结点i处，要走出迷宫所要走的边数的期望。E[1]即为所求。 
12.      
13.     叶子结点： 
14.     E[i] = ki*E[1] + ei*0 + (1-ki-ei)*(E[father[i]] + 1); 
15.          = ki*E[1] + (1-ki-ei)*E[father[i]] + (1-ki-ei); 
16.      
17.     非叶子结点：（m为与结点相连的边数） 
18.     E[i] = ki*E[1] + ei*0 + (1-ki-ei)/m*( E[father[i]]+1 + ∑( E[child[i]]+1 ) ); 
19.          = ki*E[1] + (1-ki-ei)/m*E[father[i]] + (1-ki-ei)/m*∑(E[child[i]]) + (1-ki-ei); 
20.      
21.     设对每个结点：E[i] = Ai*E[1] + Bi*E[father[i]] + Ci; 
22.      
23.     对于非叶子结点i，设j为i的孩子结点，则 
24.     ∑(E[child[i]]) = ∑E[j] 
25.                    = ∑(Aj*E[1] + Bj*E[father[j]] + Cj) 
26.                    = ∑(Aj*E[1] + Bj*E[i] + Cj) 
27.     带入上面的式子得 
28.     (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; 
29.     由此可得 
30.     Ai =        (ki+(1-ki-ei)/m*∑Aj)   / (1 - (1-ki-ei)/m*∑Bj); 
31.     Bi =        (1-ki-ei)/m            / (1 - (1-ki-ei)/m*∑Bj); 
32.     Ci = ( (1-ki-ei)+(1-ki-ei)/m*∑Cj ) / (1 - (1-ki-ei)/m*∑Bj); 
33.      
34.     对于叶子结点 
35.     Ai = ki; 
36.     Bi = 1 - ki - ei; 
37.     Ci = 1 - ki - ei; 
38.      
39.     从叶子结点开始，直到算出 A1,B1,C1; 
40.      
41.     E[1] = A1*E[1] + B1*0 + C1; 
42.     所以 
43.     E[1] = C1 / (1 - A1); 
44.     若 A1趋近于1则无解... 
45. **/  
46.   
47. #include <cstdio>  
48. #include <iostream>  
49. #include <vector>  
50. #include <cmath>  
51.   
52. using namespace std;  
53.   
54. const int MAXN = 10000 + 5;  
55.   
56. double e[MAXN], k[MAXN];  
57. double A[MAXN], B[MAXN], C[MAXN];  
58.   
59. vector<int> v[MAXN];  
60.   
61. bool search(int i, int fa)  
62. {  
63.     if ( v[i].size() == 1 && fa != -1 )  
64.     {  
65.         A[i] = k[i];  
66.         B[i] = 1 - k[i] - e[i];  
67.         C[i] = 1 - k[i] - e[i];  
68.         return true;  
69.     }  
70.   
71.     A[i] = k[i];  
72.     B[i] = (1 - k[i] - e[i]) / v[i].size();  
73.     C[i] = 1 - k[i] - e[i];  
74.     double tmp = 0;  
75.       
76.     for (int j = 0; j < (int)v[i].size(); j++)  
77.     {  
78.         if ( v[i][j] == fa ) continue;  
79.         if ( !search(v[i][j], i) ) return false;  
80.         A[i] += A[v[i][j]] * B[i];  
81.         C[i] += C[v[i][j]] * B[i];  
82.         tmp  += B[v[i][j]] * B[i];  
83.     }  
84.     if ( fabs(tmp - 1) < 1e-10 ) return false;  
85.     A[i] /= 1 - tmp;  
86.     B[i] /= 1 - tmp;  
87.     C[i] /= 1 - tmp;  
88.     return true;  
89. }  
90.   
91. int main()  
92. {  
93.     int nc, n, s, t;  
94.   
95.     cin >> nc;  
96.     for (int ca = 1; ca <= nc; ca++)  
97.     {  
98.         cin >> n;  
99.         for (int i = 1; i <= n; i++)  
100.             v[i].clear();  
101.   
102.         for (int i = 1; i < n; i++)  
103.         {  
104.             cin >> s >> t;  
105.             v[s].push_back(t);  
106.             v[t].push_back(s);  
107.         }  
108.         for (int i = 1; i <= n; i++)  
109.         {  
110.             cin >> k[i] >> e[i];  
111.             k[i] /= 100.0;  
112.             e[i] /= 100.0;  
113.         }  
114.           
115.         cout << "Case " << ca << ": ";  
116.         if ( search(1, -1) && fabs(1 - A[1]) > 1e-10 )  
117.             cout << C[1]/(1 - A[1]) << endl;  
118.         else  
119.             cout << "impossible" << endl;  
120.     }  
121.     return 0;  
122. }