CSP-S 2019 Emiya 家今天的饭

64 pts

类似 乌龟棋 的思想，由于 \(64pts\) 的 \(m <= 3\)， 非常小。

我们可以设一个 \(dp\)，建立 \(m\) 个维度存下每种物品选了几次：

• \(f[i][A][B][C]\) 表示前 \(i\) 种烹饪方法，第 \(1 / 2/ 3\) 种主要食材各自选了 \(A, B, C\) 道菜的方案数。

状态转移：根据题意，每种烹饪方法最多选一道菜。

• 不做菜 \(f[i][A][B][C] += f[i - 1][A][B][C]\)
• 做 \(1\) 道第一种主要食材的菜 ： \(f[i][A][B][C] += f[i - 1][A - 1][B][C] * a_{i, 1}\)
• 做 \(1\) 道第二种主要食材的菜 ： \(f[i][A][B][C] += f[i - 1][A][B - 1][C] * a_{i, 2}\)
• 做 \(1\) 道第三种主要食材的菜 ： \(f[i][A][B][C] += f[i - 1][A][B][C - 1] * a_{i, 3}\)

答案：\(\sum_{A = 0}^{n}\sum_{B = 0}^{n}\sum_{C = 0}^{n}f[n][A][B][C]\ (max(A, B, C) <= \lfloor(A + B + C) / 2\rfloor 且 A + B + C > 0)\)

---

小优化：发现所有状态只会从$A, B, C <= $ 自己的转移，所以可以用类似背包优化空间的思想，从大到小枚举状态，第一维可以滚动掉。

时间复杂度

最多选 \(n\) 道菜故时间复杂度 \(O(n^{m + 1})\)

#include <cstdio>
#include <iostream>
using namespace std;
const int N = 45, M = 6, P = 998244353;
int n, m, a[N][M];
typedef long long LL;
int f[N][N][N];
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++) scanf("%d", &a[i][j]);

    f[0][0][0] = 1;
    for (int i = 1; i <= n; i++) {
        for (int A = i; ~A; A--) {
            for (int B = i; ~B; B--) {
                for (int C = i; ~C; C--) {
                    if(A && a[i][1]) f[A][B][C] = (f[A][B][C] + (LL)f[A - 1][B][C] * a[i][1]) % P;
                    if(B && a[i][2]) f[A][B][C] = (f[A][B][C] + (LL)f[A][B - 1][C] * a[i][2]) % P;
                    if(m == 3 && C && a[i][3]) f[A][B][C] = (f[A][B][C] + (LL)f[A][B][C - 1] * a[i][3]) % P;
                }
            }
        }
    }
    int ans = 0;
    for (int A = n; ~A; A--) {
        for (int B = n; ~B; B--) {
            for (int C = n; ~C; C--) {
                int s = A + B + C;
                if(s > 0 && max(A, max(B, C)) <= s / 2) (ans += f[A][B][C]) %= P;
            }
        }
    }
    printf("%d\n", ans);
    return 0;
}

84 pts

发现 \(64pts\) 后的 \(m\) 猛增，所以我们的算法一定不能具体记录每种主要食材选了多少了。

我们发现一个方案不合法，有且只会有一个主要食材 $ > $ 总数的一半，所以我们不妨考虑容斥，用所有方案数量 - 不合法数量。

---

求解所有方案数量

所有方案数量很好求，做一个分组背包即可：

\(f[i][j]\) 表示前 \(i\) 种烹饪方式，做了 \(j\) 道菜的方案数。

状态转移：

• 第 \(i\) 种烹饪方式不做菜：\(f[i][j] += f[i - 1][j]\)
• 第 \(i\) 种烹饪方法做 \(1\) 道主要食材是 \(k\) 的菜：\(f[i][j] += f[i - 1][j - 1] * a_{i, k}\)

所有方案数量 $ = \sum_{j = 1}^{n}f[n][j]$

优化

1. \(i, j\) 以来比它小的 \(i', j'\)，第一维滚动掉
2. 观察第二种放菜的转移：\(f[i - 1][j - 1] * a_{i, 1} + f[i - 1][j - 1] * a_{i, 2} +...+ f[i - 1][j - 1] * a_{i, m} = f[i - 1][j - 1] * (a_{i, 1} + a_{i, 2} + ... + a_{i, m})\)。我们可以 \(O(nm)\) 预处理 \(s_i = a_{i, 1} + a_{i, 2} + ... + a_{i, m}\)。每个状态即可 \(O(1)\) 转移。

这步的时间复杂度

这步有 \(n ^ 2\) 个状态，\(O(1)\) 转移。 所以时间复杂度 \(O(n ^ 2)\)

求解不合法数量

由于刚才我们发现的性质：所有不合法方案中有且只会有一个主要食材 $ > $ 总数的一半，我们称那个主要食材为越界食材，我们设越界食材为 \(c\)。

所以我们不妨先用 \(O(m)\) 枚举 \(c\) 。

那么我们可以把其他食材归结为 符合条件的食材，我们便可以用一个维度来记录它选了多少啦~

设 \(dp[i][j][k]\) 为前 \(i\) 种烹饪方式，第 \(c\) 种（越界食材）选了 \(j\) 道，其他食材选了 \(k\) 道的方案数。

状态转移：

• 第 \(i\) 种烹饪方法不做菜：\(dp[i][j][k] += dp[i - 1][j][k]\)。\(O(1)\) 转移

• 选第 \(c\) 种（越界食材）：\(dp[i][j][k] += dp[i - 1][j - 1][k] * a_{i, c}\ (j > 0)\) \(O(1)\) 转移

• 选其他食材：\(dp[i][j][k] += \sum_{u = 1, u != c}^{m}dp[i - 1][j][k - 1] * a_{i, u} (k > 0 )\)。$O(m) $ 转移

对答案的贡献

\(\sum f[n][j][k] (j > k)\)

优化：

1. 跟之前一样可以滚动掉第一维

2. 第三种转移最耗时，考虑用求解所有方案数量优化2的思想：\(\sum_{u = 1, u != c}^{m}dp[i - 1][j][k - 1] * a_{i, u} = dp[i - 1][j][k - 1] * (\sum_{u = 1, u != c}^{m}a_{i, u}) = dp[i - 1][j][k - 1] * (s_i - a_{i, c})\) 我们就做到了 \(O(1)\) 转移。

这步的时间复杂度

\(O(m)\) 枚举越界食材后，做一个 \(O(n ^ 3)\) 的 \(dp\)。求解不合法数量的总时间复杂度为 \(O(n ^ 3m)\)。

总时间复杂度：\(O(n ^ 3m)\)

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
typedef long long LL;
const int N = 105, M = 2005, P = 998244353;
int n, m, a[N][M], f[N], s[N];
int dp[N][N];
/*
dp[i][j] 表示不合法的选了 i 个，剩下的总共选了 j 个的方案数

*/
LL ans = 0;
/*
f[i] 表示做了 i 道菜的方案数
*/

void inline add(int &x, LL y) {
    x = (x + y) % P;
}
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++) {
            scanf("%d", &a[i][j]);
            s[i] = ((LL)s[i] + a[i][j]) % P;
        }

    f[0] = 1;
    for (int i = 1; i <= n; i++)
        for (int j = i; j; j--)
            add(f[j], (LL)f[j - 1] * s[i]);

    for (int i = 1; i <= n; i++) ans = (ans + f[i]) % P;

    for (int c = 1; c <= m; c++) {
        memset(dp, 0, sizeof dp);
        dp[0][0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = i; ~j; j--) {
                for (int k = i - j; ~k; k--) {
                    if(j) add(dp[j][k], (LL)dp[j - 1][k] * a[i][c]);
                    if(k) add(dp[j][k], (LL)dp[j][k - 1] * (s[i] - a[i][c]));
                }
            }
        }

        for (int j = 1; j <= n; j++) {
            for (int k = 0; k < j; k++) ans = (ans - dp[j][k] + P) % P;
        }
    }
    printf("%lld\n", ans);
    return 0;
}

100pts

延续 \(84pts\) 的思想，求解不合法数量的 \(O(n ^ 3m)\) 拖累了我们，我们考虑优化。

我们不关系具体越界食材与其他食材选了多少。只用保证越界食材数 $ > $ 其他食材数数即为不合法状态。

---

不妨把这两个的差作为一个维度，这样即可让 \(dp\) 状态降一维：

• \(dp[i][j]\) 表示前 \(i\) 中烹饪方法，越界食材数 $ - $ 其他食材数 为 \(j\) 的方案数。

状态转移：

• 第 \(i\) 种烹饪方法不选：\(dp[i][j] += dp[i - 1][j]\)
• 选越界食材 \(c\)：\(dp[i][j] += dp[i - 1][j - 1] * a_{i, c}\)
• 选其他食材：\(dp[i][j] += dp[i - 1][j + 1] * (s_i - a_{i, c})\)。

答案贡献：

\(\sum dp[n][j] (j > 0)\)

总时间复杂度 \(O(n ^ 2m)\) 完美通过本题。

\(Tips\)：

1. 注意做差有可能为负数，我们可以把所有状态加一个 \(+n\) 的偏移量就不会数组越界了。

2. 不要忘记取模！！

#include <cstdio>
#include <iostream>
#include <cstring>
using namespace std;
typedef long long LL;
const int N = 105, M = 2005, P = 998244353;
int n, m, a[N][M], f[N], s[N];
int dp[N][N << 1];
/*
dp[i][j] 表示不合法的选了 i 个，剩下的总共选了 j 个的方案数

*/
LL ans = 0;
/*
f[i] 表示做了 i 道菜的方案数
*/

void inline add(int &x, LL y) {
    x = (x + y) % P;
}
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++) {
            scanf("%d", &a[i][j]);
            s[i] = ((LL)s[i] + a[i][j]) % P;
        }

    f[0] = 1;
    for (int i = 1; i <= n; i++)
        for (int j = i; j; j--)
            add(f[j], (LL)f[j - 1] * s[i]);

    for (int i = 1; i <= n; i++) ans = (ans + f[i]) % P;

    for (int c = 1; c <= m; c++) {
        memset(dp, 0, sizeof dp);
        dp[0][n] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n + i; j++) {
                dp[i][j] = (dp[i - 1][j] + (LL)dp[i - 1][j - 1] * a[i][c] + (LL)dp[i - 1][j + 1] * (s[i] - a[i][c])) % P;
            }
        }

        for (int j = n + 1; j <= n * 2; j++) ans = (ans - dp[n][j] + P) % P;
    }
    printf("%lld\n", ans);
    return 0;
}