LOJ2537 PKUWC2018 Minimax 树形DP、线段树合并

传送门

题意：自己去看

---

首先可以知道，每一个点都有几率被选到，所以$i$与$V_i$的关系是确定了的。

所以我们只需要考虑每一个值的取到的概率。

很容易设计出一个$DP$：设$f_{i,j}$为在第$i$个点取到权值第$j$小的点的概率，转移就是$f_{i,j}=f_{lson,j} \times (\sum \limits _{k<i} f_{rson,k} \times p_x + \sum \limits _{k > i} f_{rson,k} \times (1 - p_x))$（$lson$和$rson$之间可以交换），显然是可以前缀和优化的

当然前缀和优化也不够，$O(n^2)$只能过$40pts$。考虑优化。发现在合并的时候$lson$与$rson$之间的元素是互不冲突的，所以可以考虑线段树合并，每一次合并的时候把两边的贡献记录下来，在线段树上打标记即可。

 #include<bits/stdc++.h>
 #define ld long double
 #define int long long
 #define mid ((l + r) >> 1)
 #define lch Tree[now].ch[0]
 #define rch Tree[now].ch[1]
 //This code is written by Itst
 using namespace std;

 inline int read(){
     int a = ;
     bool f = ;
     char c = getchar();
     while(c != EOF && !isdigit(c)){
         if(c == '-')
             f = ;
         c = getchar();
     }
     while(c != EOF && isdigit(c)){
         a = (a << ) + (a << ) + (c ^ '');
         c = getchar();
     }
     return f ? -a : a;
 }

 const int MAXN =  , MOD = ;
 struct node{
     int mark , sum , ch[];
 }Tree[MAXN * ];
 int pri[MAXN] , root[MAXN] , lsh[MAXN] , ch[MAXN][] , cnt , N , cntNode , ny;

 inline void pushup(int now){
     Tree[now].sum = (Tree[lch].sum + Tree[rch].sum) % MOD;
 }

 inline void pushdown(int now){
     if(Tree[now].mark != ){
         Tree[lch].sum = Tree[lch].sum * Tree[now].mark % MOD;
         Tree[rch].sum = Tree[rch].sum * Tree[now].mark % MOD;
         Tree[lch].mark = Tree[lch].mark * Tree[now].mark % MOD;
         Tree[rch].mark = Tree[rch].mark * Tree[now].mark % MOD;
         Tree[now].mark = ;
     }
 }

 void insert(int& now , int l , int r , int tar){
     if(!now){
         now = ++cntNode;
         Tree[now].mark = ;
     }
     if(l == r){
         Tree[now].sum = ;
         return;
     }
     pushdown(now);
     if(mid >= tar)
         insert(lch , l , mid , tar);
     else
         insert(rch , mid +  , r , tar);
     pushup(now);
 }

 int mer(int p , int q , int markp , int markq , int pri){
     if(!(p + q))
         return ;
     if(!p){
         Tree[q].mark = Tree[q].mark * markq % MOD;
         Tree[q].sum = Tree[q].sum * markq % MOD;
         return q;
     }
     if(!q){
         Tree[p].mark = Tree[p].mark * markp % MOD;
         Tree[p].sum = Tree[p].sum * markp % MOD;
         return p;
     }
     pushdown(p);
     pushdown(q);
     int m1 = Tree[Tree[q].ch[]].sum , n1 = Tree[Tree[p].ch[]].sum , m2 = Tree[Tree[q].ch[]].sum , n2 = Tree[Tree[p].ch[]].sum;
     Tree[p].ch[] = mer(Tree[p].ch[] , Tree[q].ch[] , (markp + m1 * ( - pri) % MOD * ny) % MOD , (markq + n1 * ( - pri) % MOD * ny) % MOD , pri);
     Tree[p].ch[] = mer(Tree[p].ch[] , Tree[q].ch[] , (markp + m2 * pri % MOD * ny) % MOD , (markq + n2 * pri % MOD * ny) % MOD , pri);
     pushup(p);
     return p;
 }

 int getAns(int now , int l , int r){
     if(l == r)
         return l * lsh[l] % MOD * Tree[now].sum % MOD * Tree[now].sum % MOD;
     else{
         pushdown(now);
         return (getAns(lch , l , mid) + getAns(rch , mid +  , r)) % MOD;
     }
 }

 void dfs(int now){
     if(!ch[now][])
         insert(root[now] ,  , cnt , pri[now]);
     else
         if(!ch[now][]){
             dfs(ch[now][]);
             root[now] = root[ch[now][]];
         }
         else{
             dfs(ch[now][]);
             dfs(ch[now][]);
             root[now] = mer(root[ch[now][]] , root[ch[now][]] ,  ,  , pri[now]);
         }
 }

 inline int poww(long long a , int b){
     int times = ;
     while(b){
         if(b & )
             times = times * a % MOD;
         a = a * a % MOD;
         b >>= ;
     }
     return times;
 }

 signed main(){
 #ifndef ONLINE_JUDGE
     freopen("2537.in" , "r" , stdin);
     //freopen("2537.out" , "w" , stdout);
 #endif
     N = read();
     for(int i =  ; i <= N ; ++i){
         int a = read();
         if(!ch[a][])
             ch[a][] = i;
         else
             ch[a][] = i;
     }
     ny = poww( , MOD - );
     for(int i =  ; i <= N ; ++i){
         pri[i] = read();
         if(!ch[i][])
             lsh[++cnt] = pri[i];
     }
     sort(lsh +  , lsh + cnt + );
     for(int i =  ; i <= N ; ++i)
         if(!ch[i][])
             pri[i] = lower_bound(lsh +  , lsh + cnt +  , pri[i]) - lsh;
     dfs();
     cout << getAns(root[] ,  , cnt);
     return ;
 }