loj #2538. 「PKUWC2018」Slay the Spire

$ \color{#0066ff}{ 题目描述 }$

九条可怜在玩一个很好玩的策略游戏：Slay the Spire，一开始九条可怜的卡组里有 $2n$ 张牌，每张牌上都写着一个数字$w_i$，一共有两种类型的牌，每种类型各 $n$ 张：

攻击牌：打出后对对方造成等于牌上的数字的伤害。
强化牌：打出后，假设该强化牌上的数字为$x$，则其他剩下的攻击牌的数字都会乘上 $x$。保证强化牌上的数字都大于 1。

现在九条可怜会等概率随机从卡组中抽出 $m$ 张牌，由于费用限制，九条可怜最多打出 $k$ 张牌，假设九条可怜永远都会采取能造成最多伤害的策略，求她期望造成多少伤害。

假设答案为 $\text{ans}$，你只需要输出

$\left (\text{ans}\times \frac{(2n)!}{m!(2n-m)!}\right) ~\bmod 998244353$

即可

其中 $x!$ 表示 $\prod_{i=1}^{x}i$，特别地，$0!=1$

$\color{#0066ff}{输入格式}$

第一行一个正整数 $T$ 表示数据组数

接下来对于每组数据：

第一行三个正整数 $n,m,k$

第二行 $n$ 个正整数 $w_i$，表示每张强化牌上的数值。

第三行 $n$ 个正整数 $w_i$，表示每张攻击牌上的数值。

$\color{#0066ff}{输出格式}$

输出 $T$ 行，每行一个非负整数表示每组数据的答案。

$\color{#0066ff}{输入样例}$

2
2 3 2
2 3
1 2
10 16 14
2 3 4 5 6 7 8 9 10 11
1 2 3 4 5 6 7 8 9 10

$\color{#0066ff}{输出样例}$

19
253973805

$\color{#0066ff}{数据范围与提示}$

对于所有数据，有 $1\leq k\leq m\leq 2n\leq 3\times 10^3$，且$1\leq w_i\leq 10^8$。

保证强化牌上的数字都大于 1。

以下 $(\sum 2n)$ 表示对于输入中所有数据的$2n$的和。

对于 $10\%$ 的数据，有 $1\leq \sum 2n\leq 10$

对于 $20\%$ 的数据，有 $1\leq \sum 2n\leq 100$

对于 $30\%$ 的数据，有 $1\leq \sum 2n\leq 500$

另有 $20\%$ 的数据，满足所有攻击牌的数值相同。

另有 $20\%$ 的数据，满足 $m=k$。

对于 $100\%$ 的数据，有 $1\leq \sum 2n\leq 30000$

$\color{#0066ff}{题解}$

假如说我们已经有了m张牌，现在考虑怎么打出k张牌会最优呢

首先，一定是先打强化牌再打攻击牌最优，不解释

那么到底选多少攻击牌和强化牌呢

首先，我们先把m张牌分两类从大到小排序，那么肯定是选两类牌的一个前缀

比如，强化3 2，攻击a b，$k=3$

那么显然$23a=3a+3a>3a+3b$

因此，我们要尽可能多的选强化牌，剩下的选攻击牌

我们设状态$f[i][j][0/1]$表示强化牌中，前i张选j张，第i张选不选（这是为了统计方案不重不漏）的贡献

举个锤子，比如强化牌5 4 3 2，那么$f[4][3][1]$就是$2 * 3 * 5+2 * 4 * 5+2 * 3 * 4$，就是所有合法贡献的和

同理$g[i][j][0/1]$是针对ATK的DP

转移很容易，$O(n^2)$

f[0][0][0] = 1;
for(int i = 1; i <= n; i++) {
	for(int j = 0; j <= i; j++) {
		if(j >= 1) {
			f[i][j][1] = ((f[i - 1][j - 1][1] + f[i - 1][j - 1][0]) % mod * STG[i] % mod);
			g[i][j][1] = ((g[i - 1][j - 1][1] + g[i - 1][j - 1][0]) % mod + ATK[i] * C(i - 1, j - 1) % mod) % mod;
		}
		f[i][j][0] = (f[i - 1][j][0] + f[i - 1][j][1]);
		g[i][j][0] = (g[i - 1][j][0] + g[i - 1][j][1]);
	}
}

之后我们开始统计方案

为了不重不漏，我们分别在两个序列枚举端点i和j

首先考虑已有的m张牌中，强化牌$\ge k-1$张

那么我们肯定是选前$k-1$张大的强化牌和1张攻击牌，剩下的$m-k$放在其它位置

$f[i][k-1][1]*g[j][1][1]*C_{2n -i-j}^{m-k}$

如果没有那么多，只只有$w,w<k-1$张，我们肯定都选，然后剩下的$k-w$张是攻击牌，注意，这时候剩下的$m-k$张牌必须只能是攻击牌，因为强化牌不够！

$f[i][w][1]*g[j][k-w][1]*C_{n-j}^{m-k}$

注意当不选强化牌的时候要特判一下，即$k=1$的时候，还有$k\ne 1$时不选强化牌的情况，直接统计方案的话因为f是0，所以最后就是0，显然不对了，单独算一下就行

#include<bits/stdc++.h>
#define LL long long
LL in() {
	char ch; LL x = 0, f = 1;
	while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
	for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
	return x * f;
}
const int mod = 998244353;
const int maxn = 3030;
LL f[maxn][maxn][2], g[maxn][maxn][2];
LL ATK[maxn], STG[maxn], fac[maxn << 1], inv[maxn << 1];
int n, m, k;
LL ksm(LL x, LL y) {
	LL re = 1LL;
	while(y) {
		if(y & 1) re = re * x % mod;
		x = x * x % mod;
		y >>= 1;
	}
	return re;
}
LL C(int x, int y) {
	if(x < y) return 0;
	return fac[x] * inv[y] % mod * inv[x - y] % mod;
}
void predoit() {
	std::sort(STG + 1, STG + n + 1, std::greater<LL>());
	std::sort(ATK + 1, ATK + n + 1, std::greater<LL>());
	f[0][0][0] = 1;
	for(int i = 1; i <= n; i++) {
		for(int j = 0; j <= i; j++) {
			if(j >= 1) {
				f[i][j][1] = ((f[i - 1][j - 1][1] + f[i - 1][j - 1][0]) % mod * STG[i] % mod);
				g[i][j][1] = ((g[i - 1][j - 1][1] + g[i - 1][j - 1][0]) % mod + ATK[i] * C(i - 1, j - 1) % mod) % mod;
			}
			f[i][j][0] = (f[i - 1][j][0] + f[i - 1][j][1]);
			g[i][j][0] = (g[i - 1][j][0] + g[i - 1][j][1]);
		}
	}
}
void fuck() {
	LL ans = 0;
	for(int i = k - 1; i <= n; i++)
		for(int j = 1; j <= n; j++)
			(ans += f[i][k - 1][1] * g[j][1][1] % mod * C((n << 1) - i - j, m - k) % mod) %= mod;
	for(int w = 1; w <= k - 2; w++) {
		LL tot = 0;
		for(int i = 1; i <= n; i++) (tot += f[i][w][1]) %= mod;
		for(int i = 1; i <= n; i++) (ans += tot * g[i][k - w][1] % mod * C(n - i, m - k) % mod) %= mod;
	}
	for(int i = 1; i <= n; i++) (ans += g[i][k][1] * C(n - i, m - k) % mod) %= mod;
	printf("%lld\n", ans);
}
void work() {
	LL ans = 0;
	for(int i = 1; i <= n; i++) (ans += ATK[i] * C((n << 1) - i, m - k) % mod) %= mod;
	printf("%lld\n", ans);
}
int main() {
	fac[0] = 1;
	for(LL i = 1; i <= 6000; i++) fac[i] = i * fac[i - 1] % mod;
	inv[6000] = ksm(fac[6000], mod - 2);
	for(LL i = 5999; i >= 0; i--) inv[i] = (i + 1) * inv[i + 1] % mod;
	for(int T = in(); T --> 0;) {
		n = in(), m = in(), k = in();
		for(int i = 1; i <= n; i++) STG[i] = in();
		for(int i = 1; i <= n; i++) ATK[i] = in();
		predoit();
		if(k == 1) work();
		else fuck();
	}
	return 0;
}