Luogu5298 [PKUWC2018]Minimax

太久没写博客了，过来水一发。

题目链接：洛谷

---

首先我们想到，考虑每个叶节点的权值为根节点权值的概率。首先要将叶节点权值离散化。

假设现在是$x$节点，令$f_i,g_i$分别表示左/右节点的权值$=i$的概率。

若$w_x$来自于左儿子，则

$$P(w_x=i)=f_i*(p_x*\sum_{j=1}^{i-1}g_j+(1-p)*\sum_{j=i+1}^mg_j)$$

右儿子也是一样的。

所以在转移的时候需要顺便维护$f,g$的前/后缀和。

但是我们发现这样直接跑是$O(n^2)$的，肯定不行，但是每个节点的所有dp值都只依赖于两个儿子，而且区间乘法是可以使用lazy_tag的，所以可以使用线段树合并。

（等会儿，好像之前并没有写过。。。）

线段树合并就是对于值域线段树，合并的时候如果两棵树都有这个节点，那么就递归下去，否则直接按照上面的式子转移。

$f,g$的前/后缀和也可以放在参数里面顺便维护了。

 #include<bits/stdc++.h>
 #define Rint register int
 using namespace std;
 typedef long long LL;
 const int N = , mod = , inv = ;
 int n, v[N], tot, p[N], fa[N], head[N], to[N], nxt[N];
 inline void add(int a, int b){
     static int cnt = ;
     to[++ cnt] = b; nxt[cnt] = head[a]; head[a] = cnt;
 }
 int root[N], ls[N << ], rs[N << ], seg[N << ], tag[N << ], cnt, ans;
 inline void pushdown(int x){
     if(x && tag[x] != ){
         if(ls[x]){
             seg[ls[x]] = (LL) seg[ls[x]] * tag[x] % mod;
             tag[ls[x]] = (LL) tag[ls[x]] * tag[x] % mod;
         }
         if(rs[x]){
             seg[rs[x]] = (LL) seg[rs[x]] * tag[x] % mod;
             tag[rs[x]] = (LL) tag[rs[x]] * tag[x] % mod;
         }
         tag[x] = ;
     }
 }
 inline void change(int &x, int L, int R, int pos){
     if(!x) tag[x = ++ cnt] = ;
     pushdown(x);
     ++ seg[x];
     if(seg[x] >= mod) seg[x] = ;
     if(L == R) return;
     int mid = L + R >> ;
     if(pos <= mid) change(ls[x], L, mid, pos);
     else change(rs[x], mid + , R, pos);
 }
 inline int merge(int lx, int rx, int L, int R, int pl, int pr, int sl, int sr, int P){
     if(!lx && !rx) return ;
     int now = ++ cnt, mid = L + R >> ; tag[now] = ;
     pushdown(lx); pushdown(rx);
     if(!lx){
         int v = ((LL) P * sl + (mod + 1ll - P) * sr) % mod;
         seg[now] = (LL) seg[rx] * v % mod;
         tag[now] = (LL) tag[rx] * v % mod;
         ls[now] = ls[rx]; rs[now] = rs[rx];
         return now;
     }
     if(!rx){
         int v = ((LL) P * pl + (mod + 1ll - P) * pr) % mod;
         seg[now] = (LL) seg[lx] * v % mod;
         tag[now] = (LL) tag[lx] * v % mod;
         ls[now] = ls[lx]; rs[now] = rs[lx];
         return now;
     }
     ls[now] = merge(ls[lx], ls[rx], L, mid, pl, (pr + seg[rs[rx]]) % mod, sl, (sr + seg[rs[lx]]) % mod, P);
     rs[now] = merge(rs[lx], rs[rx], mid + , R, (pl + seg[ls[rx]]) % mod, pr, (sl + seg[ls[lx]]) % mod, sr, P);
     seg[now] = (seg[ls[now]] + seg[rs[now]]) % mod;
     return now;
 }
 inline void getans(int x, int L, int R){
     pushdown(x);
     if(L == R){
         ans = (ans + (LL) seg[x] * seg[x] % mod * v[L] % mod * L % mod) % mod;
         return;
     }
     int mid = L + R >> ;
     getans(ls[x], L, mid);
     getans(rs[x], mid + , R);
 }
 inline void dfs(int x){
     if(!head[x]){
         change(root[x], , n, p[x]);
         return;
     }
     for(Rint i = head[x];i;i = nxt[i]){
         dfs(to[i]);
         if(!root[x]) root[x] = root[to[i]];
         else root[x] = merge(root[x], root[to[i]], , n, , , , , p[x]);
     }
 }
 int main(){
     scanf("%d", &n);
     for(Rint i = ;i <= n;i ++){
         scanf("%d", fa + i);
         if(fa[i]) add(fa[i], i);
     }
     for(Rint i = ;i <= n;i ++){
         scanf("%d", p + i);
         if(head[i]) p[i] = (LL) p[i] * inv % mod;
         else v[++ tot] = p[i];
     }
     sort(v + , v + tot + );
     for(Rint i = ;i <= n;i ++)
         if(!head[i]) p[i] = lower_bound(v + , v + tot + , p[i]) - v;
     dfs();
     getans(root[], , n);
     printf("%d", ans);
 }

luogu5369