LOJ2538 PKUWC2018 Slay the Spire DP

传送门

不想放题面了，咕咕咕咕咕

---

这个期望明明是用来吓人的，其实要算的就是所有方案的最多伤害的和。

首先可以知道的是，能出强化牌就出强化牌（当然最后要留一张攻击牌出出去），且数字尽量大

所以说在强化牌数量$< K$时会打出所有强化牌和剩下的最大的攻击牌，而强化牌数量$\geq K$的时候则会打出$K-1$张强化牌和$1$张攻击牌，且它们的数字都是最大的

我们不妨计算每一种最优打出的方案存在在多少种抽取方案中。

设$f_{i,j}$表示使用$i$张强化牌，其中数值最小的牌是第$j$张时的方案的强化数值之和，$g_{i,j}$表示使用$i$张攻击牌，其中数值最小的牌是第$j$张时的方案的攻击数值之和，简单的前缀和优化DP就可以完成。处理完之后，所有抽取了$x$张强化牌和$y$张攻击牌，选择$i$张强化牌和$j$张攻击牌的方案的总伤害和就是

$$\sum\limits_k \sum\limits_l f_{i,k} \times g_{j,l} \times C_{k-1}^{x-i} \times C_{l-1}^{y-j}$$

两个理解：

①$f$和$g$中间用乘号是因为$f$中间的每一个方案和$g$中的每一个方案都可以对应产生一种抽取方式

②后面的两个组合数的意思是：对于强化牌，已经使用了$i$张，最小的是$k$，那么剩下的$x-i$张需要在剩余的$k-1$中抽取，方案数就是组合数，后面同理

那么我们枚举强化牌抽了多少张，就可以直接计算答案。

 #include<bits/stdc++.h>
 //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 MOD =  , MAXN = ;
 long long dp[MAXN + ][MAXN + ] , f[MAXN + ][MAXN + ] , g[MAXN + ][MAXN + ] , num[][MAXN + ] , jc[MAXN + ] , ny[MAXN + ] , N , M , K , ans;

 bool cmp(int a , int b){
     return a > b;
 }

 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("2538.in" , "r" , stdin);
     //freopen("2538.out" , "w" , stdout);
 #endif
     jc[] = ;
     for(long long i =  ; i <= MAXN ; ++i)
         jc[i] = jc[i - ] * i % MOD;
     ny[MAXN] = poww(jc[MAXN] , MOD - );
     for(long long i = MAXN -  ; i >=  ; --i)
         ny[i] = ny[i + ] * (i + ) % MOD;
     for(int i =  ; i <= MAXN ; ++i)
         dp[][i] = ;
     for(int i =  ; i <= MAXN ; ++i)
         for(int j =  ; j <= MAXN ; ++j)
             dp[i][j] = (dp[i - ][j - ] + dp[i][j - ]) % MOD;
     for(int i =  ; i <= MAXN ; ++i)
         f[][i] = ;

     for(int T = read() ; T ; --T){
         N = read();
         M = read();
         K = read();
         for(int i =  ; i <= N ; ++i)
             num[][i] = read();
         sort(num[] +  , num[] + N +  , cmp);
         for(int i =  ; i <= N ; ++i)
             num[][i] = read();
         sort(num[] +  , num[] + N +  , cmp);
         ans = ;

         for(int i =  ; i <= N ; ++i)
             for(int j =  ; j <= N ; ++j){
                 f[i][j] = (1ll * f[i - ][j - ] * num[][j] + f[i][j - ]) % MOD;
                 g[i][j] = (g[i - ][j - ] + 1ll * (dp[i][j] - dp[i][j - ] + MOD) * num[][j] + g[i][j - ]) % MOD;
             }

         for(int i =  ; i < K ; ++i){
             int sum1 = f[i][N] , sum2 = ;
             for(int j = K - i ; N - j >= M - K ; ++j)
                 sum2 = (sum2 + 1ll * (g[K - i][j] - g[K - i][j - ] + MOD) * jc[N - j] % MOD * ny[M - K] % MOD * ny[N - j - (M - K)]) % MOD;
             ans = (ans + 1ll * sum1 * sum2) % MOD;
         }

         for(int i = K ; i < M ; ++i){
             int sum1 =  , sum2 = ;
             for(int j = K -  ; N - j >= i - (K - ) ; ++j)
                 sum1 = (sum1 + 1ll * (f[K - ][j] - f[K - ][j - ] + MOD) * jc[N - j] % MOD * ny[i - (K - )] % MOD * ny[N - j - (i - (K - ))]) % MOD;
             for(int j =  ; N - j >= M - i -  ; ++j)
                 sum2 = (sum2 + 1ll * (g[][j] - g[][j - ] + MOD) * jc[N - j] % MOD * ny[M - i - ] % MOD * ny[N - j - (M - i - )]) % MOD;
             ans = (ans + 1ll * sum1 * sum2) % MOD;
         }
         cout << ans << endl;
     }
     return ;
 }