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 = 0;
    bool f = 0;
    char c = getchar();
    while(c != EOF && !isdigit(c)){
        if(c == '-')
            f = 1;
        c = getchar();
    }
    while(c != EOF && isdigit(c)){
        a = (a << 3) + (a << 1) + (c ^ '0');
        c = getchar();
    }
    return f ? -a : a;
}

const int MOD = 998244353 , MAXN = 3000;
long long dp[MAXN + 10][MAXN + 10] , f[MAXN + 10][MAXN + 10] , g[MAXN + 10][MAXN + 10] , num[2][MAXN + 10] , jc[MAXN + 10] , ny[MAXN + 10] , N , M , K , ans;

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

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

signed main(){
#ifndef ONLINE_JUDGE
    freopen("2538.in" , "r" , stdin);
    //freopen("2538.out" , "w" , stdout);
#endif
    jc[0] = 1;
    for(long long i = 1 ; i <= MAXN ; ++i)
        jc[i] = jc[i - 1] * i % MOD;
    ny[MAXN] = poww(jc[MAXN] , MOD - 2);
    for(long long i = MAXN - 1 ; i >= 0 ; --i)
        ny[i] = ny[i + 1] * (i + 1) % MOD;
    for(int i = 0 ; i <= MAXN ; ++i)
        dp[0][i] = 1;
    for(int i = 1 ; i <= MAXN ; ++i)
        for(int j = 1 ; j <= MAXN ; ++j)
            dp[i][j] = (dp[i - 1][j - 1] + dp[i][j - 1]) % MOD;
    for(int i = 0 ; i <= MAXN ; ++i)
        f[0][i] = 1;
    
    for(int T = read() ; T ; --T){
        N = read();
        M = read();
        K = read();
        for(int i = 1 ; i <= N ; ++i)
            num[0][i] = read();
        sort(num[0] + 1 , num[0] + N + 1 , cmp);
        for(int i = 1 ; i <= N ; ++i)
            num[1][i] = read();
        sort(num[1] + 1 , num[1] + N + 1 , cmp);
        ans = 0;
        
        for(int i = 1 ; i <= N ; ++i)
            for(int j = 1 ; j <= N ; ++j){
                f[i][j] = (1ll * f[i - 1][j - 1] * num[0][j] + f[i][j - 1]) % MOD;
                g[i][j] = (g[i - 1][j - 1] + 1ll * (dp[i][j] - dp[i][j - 1] + MOD) * num[1][j] + g[i][j - 1]) % MOD;
            }

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