【SHTSC2014】概率充电器

Description

著名的电子产品品牌SHOI刚刚发布了引领世界潮流的下一代电子产品——概率充电器：

“采用全新纳米级加工技术，实现元件与导线能否通电完全由真随机数决定！SHOI概率充电器，您生活不可或缺的必需品！能充上电吗？现在就试试看吧！”

SHOI概率充电器由n-1条导线连通了n个充电元件。进行充电时，每条导线是否可以导电以概率决定，每一个充电元件自身是否直接进行充电也由概率决定。随后电能可以从直接充电的元件经过通电的导线使得其他充电元件进行间接充电。

作为SHOI公司的忠实客户，你无法抑制自己购买SHOI产品的冲动。在排了一个星期的长队之后终于入手了最新型号的SHOI概率充电器。你迫不及待地将SHOI概率充电器插入电源——这时你突然想知道，进入充电状态的元件个数的期望是多少呢？

Input

第一行一个整数：n。概率充电器的充电元件个数。充电元件由1-n编号。

之后的n-1行每行三个整数a, b, p，描述了一根导线连接了编号为a和b的充电元件，通电概率为p%。

第n+2行n个整数：qi。表示i号元件直接充电的概率为qi%。

Output

输出一行一个实数，为能进入充电状态的元件个数的期望，四舍五入到小数点后6位小数。

Sample Input

输入1：

3
1 2 50
1 3 50
50 0 0

输入2：
5
1 2 90
1 3 80
1 4 70
1 5 60
100 10 20 30 40

Sample Output
输出1：
1.000000
输出2：
4.300000
Data Constraint
对于30%的数据，n≤5000。
对于100%的数据，n≤500000，0≤p,qi≤100。

The Solution

先来口胡一波

首先题意背景是在树上的。
我们考虑树形DP

如何DP

首先我们需要知道一个概率的公式，
对于两个相互独立的事件A、B，

$$P(A+B)=P(A)+P(B)-P(AB)。$$
每个点都给它们的所有儿子贡献了一部分概率，
第一次DFS时，我们需要求出每个点u的每个儿子v的充电概率 $P'(v)=P(v)+[P(u)*p(E[k])]-[P(u)*p(E[k])]*P(v)$。
可以认为 $P(E[k])$是边权吧。
由于第一次DFS时会混进重复计算的概率（因为父亲节点给本节点的概率不能被算进本节点给儿子节点的概率），
所以要再进行一次DFS，去除掉重复的概率。

注意

单纯的DFS毫无疑问会爆栈。大概有80~70分。
我们考虑人工栈或用栈模拟DFS的过程，要留意
DFS（）里只能含一个局域变量，不然依然GG
这是经过验证的

CODE

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <queue>
#include <cstring>
#include <stack>
#define fo(i,a,b) for (int i=a;i<=b;i++)
#define fd(i,a,b) for (int i=a;i>=b;i--)
#define EPS (1E-6)

using namespace std;

const int N = 1001000;

typedef double db;

stack <int> S;

struct Edge
{
    int to,next;
    db p;
    Edge(void){}
    Edge(int a,int b,db c) : to(a),next(b),p(c){} 
}E[N];


int Final[N],tot;
bool Flag[N];
db f[N],P_Dire[N],Ans,t,y;
int xh[N];

void Link(int x,int y,db z)
{
    E[++ tot] = Edge(y,Final[x],z),Final[x] = tot;
    E[++ tot] = Edge(x,Final[y],z),Final[y] = tot;
}

int read(int &n)
{
    char ch = ' ';
    int q = 0, w = 1;
    for (;(ch != '-') && ((ch < '0') || (ch> '9'));ch = getchar());
    if (ch == '-') w = -1,ch = getchar();
    for (; ch >= '0' && ch <= '9';ch = getchar()) q = q * 10 + ch - 48;
    n = q * w;
    return n;
}

void Clear(stack<int>& S) 
{
    stack<int> empty;
    swap(empty, S);
}

//void Dfs(int x,int fa)
void Dfs()
{
        int x = S.top();
        Flag[x] = true;
        for (xh[x] = Final[x];xh[x];xh[x] = E[xh[x]].next)
        if (Flag[E[xh[x]].to] == false)
        {
            //Dfs(E[k].to,x);
            S.push(E[xh[x]].to);
            Flag[E[xh[x]].to] = true;
            Dfs();
            P_Dire[x] = P_Dire[x] + P_Dire[E[xh[x]].to] * E[xh[x]].p - P_Dire[x] * E[xh[x]].p * P_Dire[E[xh[x]].to];
        }   

        S.pop();
}

void Dfs2()
{
    //Ans += f[1];
        int x = S.top();
        Ans += f[x];
        Flag[x] = true;
        for (xh[x] = Final[x];xh[x];xh[x] = E[xh[x]].next)
        if (! Flag[E[xh[x]].to])
        {
             t = (1 - P_Dire[E[xh[x]].to] * E[xh[x]].p);
            if (fabs(t - 0) < EPS) f[E[xh[x]].to] = 1.0;
            else
            {
                 y = (db)(f[x] - P_Dire[E[xh[x]].to] * E[xh[x]].p) / (db)(1 - P_Dire[E[xh[x]].to] * E[xh[x]].p);
                f[E[xh[x]].to] = P_Dire[E[xh[x]].to] + y * E[xh[x]].p - P_Dire[E[xh[x]].to] * y * E[xh[x]].p;
            }
            S.push(E[xh[x]].to);
            Flag[E[xh[x]].to] = true;
            //swap(E[k].to,x);
            Dfs2();
        }
    S.pop();
}

int main()
{
    freopen("charger.in","r",stdin);
    freopen("charger.out","w",stdout); 
    int n;
    read(n);
    fo(i,1,n - 1)
    {
        int x,y,p;
        read(x),read(y),read(p);    
        Link(x,y,(db)p / (db)100);
    }
    fo(i,1,n)   
    {
        scanf("%lf",&P_Dire[i]);
        P_Dire[i] /= 100;   
    }
    S.push(1);
    Dfs();
    f[1] = P_Dire[1]; 
    Clear(S);
    memset(Flag,false,sizeof(Flag));
    S.push(1);
    Dfs2();
    printf("%.6f\n",Ans);
    return 0;
}