CF1628D1

设 $dp[i][j]$ 表示 $i$ 次操作，至少有 $j$ 次要加 $t$

首先加一下初始化：

• $dp[i][0] = 0$，即当要加 $0$ 次时，Bob 一定会狂减，那 Alice 每次选 $0$ 最优

• $dp[i][i] = i \times k$，即 Bob 要全加，那 Alice 每次选 $k$ 最优

接下来我们来考虑怎么转移，假设我们准备转移 $dp[i][j]$

当选到第 $i$ 轮时，Bob 有两种选法：

• 加 $t$，因为 Bob 一定只会加 $j$，也就是说 Bob 以前会加 $j - 1$ 次，所以转移过来的数为 $dp[i - 1][j - 1] + t$
• 减 $t$，同理， Bob 以前会加 $j$ 次，所以转移过来的数为 $dp[i - 1][j] - t$

所以，Alice 会选使得 $\min (dp[i - 1][j - 1] + t, dp[i - 1][j] - t)$ 最大的 $t$，那么$$ dp[i][j] = \max_{0 \leq l \leq k} \{\min (dp[i - 1][j - 1] + l, dp[i - 1][j] - l)\} $$ 但若暴力枚举 $l$ ，肯定会超时，考虑优化

容易发现，当 $l= \dfrac{dp[i - 1][j - 1] + dp[i - 1][j]}{2}$ 时，

$\min (dp[i - 1][j - 1] + l, dp[i - 1][j] - l) = \dfrac{dp[i - 1][j - 1] + dp[i - 1][j]}{2}$ 取的值最大，

所以，总结一下得到：$$ dp[i][j]=\begin{cases}0&j = 0\\i\times k&j =i\\\dfrac{dp[i - 1][j - 1] + dp[i - 1][j]}{2}&1 \leq j \leq i - 1\end{cases} $$ 因为有 $T$ 组询问，所以若每次都做一次，复杂度为 $O(Tnm)$，肯定会超时，

但唯独 $k$ 在转移中出现，我们就考虑可不可以在转移中出掉 $k$，

经过一番思考，显然，$dp[j][j] = k \times f[i][j]$ ，为什么呢？

因为在转移的过程中，唯有额外的常数，而初始化都可以表示成上面的式子，

$f[i][j]$ 怎么转移呢？很简单，只要把上面的 $f[i][i] = i$ 就行了，总结一下，$$ f[i][j] = \begin{cases}0&j=0\\i&j=i\\\dfrac{f[i - 1][j - 1] + dp[i - 1][j]}{2} & 1\leq j \leq i - 1\end{cases} $$ 最后查询的时候输出 $k \times f[n][m]$ 即可。

在代码中，本蒟蒻用 $dp[i][j]$ 替代 $f[i][j]$ 了

#include <cstdio>
#include <iostream>
using namespace std;
#define int long long

const int maxn = 2010, mod = 1e9 + 7;
int dp[maxn][maxn];

int ksm (int x, int y){
    int res = 1;
    while (y) {
        if (y & 1) res = 1ll * res * x % mod;
        x = 1ll * x * x % mod; y >>= 1;
    }
    return res;
}

signed main() {
    for (int i = 1; i < maxn; ++i) { // 预处理 dp[i][j]
        dp[i][0] = 0; dp[i][i] = i % mod;
        for (int j = 1; j < i; ++j) {
            dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j]) % mod * ksm (2, mod - 2) % mod;
        }
    }
    int T; scanf ("%lld", &T);
    while (T --) {
        int n, m, k; scanf ("%lld%lld%lld", &n, &m, &k);
        printf ("%lld\n", 1ll * dp[n][m] * k % mod);
    }
    return 0;
}