HDU4035（概率期望、树形、数学）

和ZOJ3329有些像，都是用期望列出来式子以后，为了解式子，设A[i],B[i]，此题又多了C[i]，然后用递推（此题是树形dp）去求得ABC，最后结果只跟ABC有关，跟列写的期望数组根本无关。

虽然式子很长很冗，但平心而论思维上并不难理解，关键是自信和耐心去带入。ABC的递推式出来了以后，代码就不难了。

据说eps有坑？

邝斌巨巨的：

 #pragma comment(linker, "/STACK:1024000000,1024000000")
 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <cmath>
 #include <ctime>
 #include <cctype>
 #include <climits>
 #include <iostream>
 #include <iomanip>
 #include <algorithm>
 #include <string>
 #include <sstream>
 #include <stack>
 #include <queue>
 #include <set>
 #include <map>
 #include <vector>
 #include <list>
 #include <fstream>
 #include <bitset>
 #define init(a, b) memset(a, b, sizeof(a))
 #define rep(i, a, b) for (int i = a; i <= b; i++)
 #define irep(i, a, b) for (int i = a; i >= b; i--)
 using namespace std;

 typedef double db;
 typedef long long ll;
 typedef unsigned long long ull;
 typedef pair<int, int> P;
 const int inf = 0x3f3f3f3f;
 const ll INF = 1e18;

 template <typename T> void read(T &x) {
     x = ;
     int s = , c = getchar();
     for (; !isdigit(c); c = getchar())
         if (c == '-')    s = -;
     for (; isdigit(c); c = getchar())
         x = x *  + c - ;
     x *= s;
 }

 template <typename T> void write(T x) {
     if (x < )    x = -x, putchar('-');
     if (x > )    write(x / );
     putchar(x %  + '');
 }

 template <typename T> void writeln(T x) {
     write(x);
     puts("");
 }

 const int maxn = 1e4 + ;
 const db eps = 1e-;
 int T, n, kase;
 db A[maxn], B[maxn], C[maxn], K[maxn], E[maxn];
 vector<int> v[maxn];

 bool dfs(int cur, int fa) {
     int m = v[cur].size();
     if (m ==  && fa) {
         A[cur] = K[cur];
         B[cur] = C[cur] = 1.0 - K[cur] - E[cur];
     } else {
         db tmp = ( - K[cur] - E[cur]) / m;
         db Atmp = , Btmp = , Ctmp = ;
         for (int child : v[cur]) {
             if (child != fa) {
                 if (!dfs(child, cur))    return false;
                 Atmp += A[child];
                 Btmp += B[child];
                 Ctmp += C[child];
             }
         }
         if (fabs( - tmp * Btmp) < eps)    return false;
         A[cur] = (K[cur] + tmp * Atmp) / ( - tmp * Btmp);
         B[cur] = tmp / ( - tmp * Btmp);
         C[cur] = (tmp * Ctmp +  - K[cur] - E[cur]) / ( - tmp * Btmp);
     }
     return true;
 }

 int main() {
     for (read(T); T; T--) {
         read(n);
         rep(i, , n)    v[i].clear();
         rep(i, , n - ) {
             int x, y;
             read(x), read(y);
             v[x].push_back(y);
             v[y].push_back(x);
         }
         rep(i, , n) {
             read(K[i]), read(E[i]);
             K[i] /= , E[i] /= ;
         }

         printf("Case %d: ", ++kase);
         if (dfs(, ) && fabs( - A[]) > eps) {
             printf("%.6lf\n", C[] / ( - A[]));
         } else {
             puts("impossible");
         }
     }
     return ;
 }