P5299 [PKUWC2018] Slay the Spire （dp/组合计数）

P5299 [PKUWC2018] Slay the Spire

dp/组合计数

先考虑选出 $m$ 张牌之后，怎么出牌最优。首先显然的，若选出 $k$ 张牌，$x$ 张强化牌一定是前 $x$ 大的 $a_i$，$y$ 张攻击牌一定是前 $y$ 大的 $b_i$，并且肯定先用完强化牌再攻击，伤害为 $\prod _{i=1}^x{a}_i\sum _{i=1}^y{b}_i$（此时排序了）。如果 $x+1$ 张强化牌，那么伤害就是 $\prod _{i=1}^{x+1}{a}_i\sum _{i=1}^{y-1}{b}_i$。比较哪个策略更优，作差。整理得 $(a_{x+1}-1)\sum _{i=1}^{y-1}{b}_i\ge b_y$，不等式在 $y>1$ 时恒成立。所以策略就是能出强化牌就出，至少留下一张攻击牌。

那么就可做了。考虑计算所有方案的伤害总和。分成两种情况讨论，选出的 $m$ 张牌中强化牌小于 $k-1$，那么出完强化牌就出攻击牌；反之，只出前 $k-1$ 张强化，一张攻击。可以发现这些是可以预处理的。设 $f_{i,j,0/1}$ 表示前 $i$ 张强化牌选 $j$ 张的乘积和（必选第 $i$ 张/不必选第 $i$ 张），$g_{i,j,0/1}$ 表示前 $i$ 张攻击牌选 $j$ 张的和的和（必选第 $i$ 张/不必选第 $i$ 张）。转移易得。

第一种情况。考虑枚举强化牌数 $i$ 和最后一张攻击牌位置 $j$，贡献是 $f_{n,i,1}\times g_{j,k-i,0}\times C(n-j,m-k)$。

第二种情况。考虑枚举最后一张强化牌位置 $i$ 和唯一一张攻击牌位置 $j$，贡献是 $f_{i,k-1,0}\times b_j\times C(2\times n-i-j,m-k)$。

复杂度 $O(n^2)$。

#include <bits/stdc++.h>
#define pii std::pair<int, int>
#define fi first
#define se second
#define pb push_back

using i64 = long long;
using ull = unsigned long long;
const i64 iinf = 0x3f3f3f3f, linf = 0x3f3f3f3f3f3f3f3f;
const int N = 3e3 + 10, mod = 998244353;
i64 n, m, k, ans;
i64 a[N], b[N];
i64 f[N][N][2], g[N][N][2];
i64 qpow(i64 a, i64 b, i64 m) {
	i64 ret = 1;
	while(b) {
		if(b & 1) ret = ret * a % m;
		a = a * a % m;
		b >>= 1;
	}
	return ret;
}
struct BIN {
	i64 fac[N], inv[N];
	void init(int n) {
		fac[0] = 1;
		for(int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
		inv[n] = qpow(fac[n], mod - 2, mod);
		for(int i = n - 1; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
	}
	i64 C(i64 n, i64 m) {
		if(n < m) return 0;
		return fac[n] * inv[m] % mod * inv[n - m] % mod;
	}
	i64 C2(i64 n, i64 m) {
		if(n < m) return 0;	
		return fac[n] * qpow(fac[m], mod - 2, mod) % mod * qpow(fac[n - m], mod - 2, mod) % mod;
	}
	i64 lucas(i64 n, i64 m){
		if(!m) return 1;
		return C2(n % mod, m % mod) * lucas(n / mod, m / mod) % mod;
	}
} comb;
void solve() {
	std::cin >> n >> m >> k;
	for(int i = 1; i <= n; i++) {
		std::cin >> a[i];
	}
	for(int i = 1; i <= n; i++) {
		std::cin >> b[i];
	}
	std::sort(a + 1, a + n + 1, std::greater<int>());
	std::sort(b + 1, b + n + 1, std::greater<int>());
	f[0][0][0] = f[0][0][1] = 1;
	for(int i = 1; i <= n; i++) {
		f[i][0][1] = 1;
		for(int j = 1; j <= i; j++) {
			f[i][j][0] = a[i] * f[i - 1][j - 1][1] % mod;
			f[i][j][1] = (f[i][j][0] + f[i - 1][j][1]) % mod;
			g[i][j][0] = (b[i] * comb.C(i - 1, j - 1) % mod + g[i - 1][j - 1][1]) % mod;
			g[i][j][1] = (g[i][j][0] + g[i - 1][j][1]) % mod;
		}
	}
	for(int i = 0; i < k - 1; i++) {
		for(int j = 1; j <= n; j++) {
			ans = (ans + f[n][i][1] * g[j][k - i][0] % mod * comb.C(n - j, m - k) % mod) % mod;
		}
	}
	for(int i = 0; i <= n; i++) {
		for(int j = 1; j <= n; j++) {
			ans = (ans + f[i][k - 1][0] * b[j] % mod * comb.C(2 * n - i - j, m - k) % mod) % mod;
		}
	}
	for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) f[i][j][0] = f[i][j][1] = g[i][j][0] = g[i][j][1] = 0;
	std::cout << ans << "\n";
	ans = 0;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    comb.init(N - 10);

    int t;
    std::cin >> t;

	while(t--) solve();

	return 0;
}