hdu5866(cf494c,dp)

题目链接：多校第十场1010。
http://acm.split.hdu.edu.cn/showproblem.php?pid=5866
原题是cf494C
http://codeforces.com/contest/494/problem/C
参考了一下cf的tutorial和viethoho的代码。

题目大意：有n个点构成了一棵树，每个节点都有一个权值，然后树上有m个操作，作用于m个不同的节点，每个操作有p的概率成功，成功了以后包含这个点的子树的每个点的权值加一，问m个操作后树上的权值最大值的期望。

数据范围：$T <= 5,n <= 100000,m <= 3000$

Tutorial：这是一个关于期望的概率dp，根据数据范围，可以知道对m动规比较可行。

由于是树，显然是自下而上dp，并且仔细思索以后发现状态要开两维，一维是序，一维记录增量。于是我们记
$dp[i][j] 是第i个操作，子树中最大权值比初始最大权值大不超过j的概率$
我们可以先通过dfs，以$O(n)$的复杂度计算出mx数组，记录子树中的初始最大权值。
则转移方程可以写出：

$$dp[i][k] = (1 - p[i]) * \Pi dp[j][min(mx[i] - mx[j] + k,m)] + p[i] * \Pi dp[j][min(mx[i] - mx[j] + k - 1,m)] 其中j是i的后继操作$$
其中，为了方便，应该添加一个作用于root，成功概率为0的操作。
于是问题转化为如何求后继操作了。
我们可以求出每个节点在dfs操作中的入序与出序，可以发现这个操作正好对入序与出序中的点有影响，于是问题转化为了求区间关系，具体过程见代码。

最终答案等于
$dp[root][0] * mx[root] + \Sigma (dp[root][i] - dp[root][i - 1]) * (mx[root] + i)$

代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <stack>
using namespace std;

const int maxm = 3005;
const int maxn = 100000 + 5;

int n,m;

vector<int> G[maxn];
vector<int> g[maxm];

int v[maxn],mx[maxn];


int dfs_clock;
int root,deg[maxn];
int ind[maxn],outd[maxn];
int id[maxm];

void dfs(int u,int fa){
    ind[u] = ++dfs_clock;
    for(int i = 0;i < G[u].size();i++){
        int v = G[u][i];
        if(v == fa) continue;
        dfs(v,u);
    }
    outd[u] = ++dfs_clock;
}

struct segment{
    int l,r;
    int id;
    double pro;
    bool operator < (const segment & rhs) const{
        return l < rhs.l || (l == rhs.l && r > rhs.r);
    }
}s[maxm];

int Dfs(int u,int fa){
    int maxv = v[u];
    for(int i = 0;i < G[u].size();i++){
        int v = G[u][i];
        if(v == fa) continue;
        maxv = max(maxv,Dfs(v,u));
    }
    return mx[u] = maxv;
}

double dp[maxm][maxm];

void solve(int u){
    for(int i = 0;i < g[u].size();i++) solve(g[u][i]);
    for(int i = 0;i <= m;i++){
        double a = 1.0 - s[u].pro;double b = s[u].pro;
        for(int j = 0;j < g[u].size();j++){
            a *= dp[g[u][j]][min(mx[s[u].id] - mx[s[g[u][j]].id] + i,m)];
            b *= dp[g[u][j]][min(mx[s[u].id] - mx[s[g[u][j]].id] + i - 1,m)];
        }
        if(i != 0 ?dp[u][i] = a + b : dp[u][i] = a);
    }
}

int main(int argc, const char * argv[]) {
    while(scanf("%d%d",&n,&m) == 2){
        stack<int> st;
        while(!st.empty()) st.pop();
        for(int i = 1;i <= n;i++) G[i].clear();
        for(int i = 1;i <= m;i++) g[i].clear();
        for(int i = 1;i <= n;i++) deg[i] = 0;
        for(int i = 1;i < n;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            G[v].push_back(u);
            deg[u]++;
        }
        for(int i = 1;i <= n;i++){
            if(deg[i] == 0) root = i;
        }
        dfs_clock = 0;
        dfs(root,-1);
        for(int i = 1;i <= n;i++){
            scanf("%d",v + i);
        }
        for(int i = 1;i <= m;i++){
            int v;double p;
            scanf("%d%lf",&v,&p);
            s[i].l = ind[v];
            s[i].r = outd[v];
            s[i].pro = p;
            s[i].id = v;
        }
        m++;
        s[m].l = 1;
        s[m].r = dfs_clock;
        s[m].pro = 0;
        s[m].id = root;
        sort(s + 1,s + 1 + m);
        //cout << root << endl;
//        for(int i = 1;i <= m;i++) cout << s[i].l << " " << s[i].r << " " << s[i].pro << endl;
        Dfs(root,-1);
        //for(int i = 1;i <= n;i++) cout << mx[i] << endl;
        for(int i = 1;i <= m;i++){
            while(!st.empty() && s[i].r > s[st.top()].r) st.pop();
            if(!st.empty()) g[st.top()].push_back(i);
            st.push(i);
        }

        solve(1);

//        for(int i = 0;i <= m;i++) cout << dp[1][i] << endl;
        double ans = dp[1][0] * mx[root];
        for(int i = 1;i <= m;i++) ans += (dp[1][i] - dp[1][i - 1]) * (mx[root] + i);
        printf("%.6lf\n",ans);
    }
    return 0;
}