HDU 6314 Matrix（容斥原理）

最新推荐文章于 2020-09-07 09:20:43 发布

ExRoc

最新推荐文章于 2020-09-07 09:20:43 发布

阅读量496

点赞数

文章标签： HDU 6314 Matrix 容斥原理

本文链接：https://blog.csdn.net/CSDNjiangshan/article/details/81352160

版权

题目链接：Matrix

题意

对于一个 $n\times m$ 的网格，每一个小格只能涂上黑色或者白色，问所有涂色方案中，至少有 $A$ 行 $B$ 列为黑色的方案数。

输入

多组输入（不超过 $5$ 组），每组为四个整数 $n,m,A,B~(1\leq n,m,A,B\leq3000)$

输出

输出方案数对 $998244353$ 取模的结果。

样例

输入
3 4 1 2
输出
169

题解

根据容斥原理可以知道，至少 $A$ 行 $B$ 列为黑色的方案数为 $\sum_{i=A}^nf_{ai}C_n^i\sum_{j=B}^mf_{bj}C_m^j$ ，如果 $i$ 和 $j$ 是从 $1$ 开始的，那么 $f_{ai}f_{bj}$ 的值就为 $(-1)^{i+j}$ ，然而 $i$ 和 $j$ 不是从 $1$ 开始的，而是从某个数字开始的，于是该系数就为 $f_{ai}=1-\sum_{k=A}^iC_i^kf_{ak},~f_{bj}=1-\sum_{k=B}^jC_j^kf_{bk}$ 。系数 $f_{ai}$ 具体的推导可以根据在 $k\in[A,i)$ 容斥的加减计算过程中，至少为 $i$ 行的状态被重复计算的次数来得到。最后对 $f_{ai}$ 和 $f_{bj}$ 进行 $O(n^2+m^2)$ 次预处理，再 $O(nm)$ 地计算容斥公式，就可以得到答案。

过题代码

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cstring>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <bitset>
#include <algorithm>
#include <sstream>
using namespace std;

#define LL long long
const int maxn = 3001;
const int MOD = 998244353;
int n, m, A, B, ans;
int C[maxn][maxn], two[maxn * maxn];
int fa[maxn], fb[maxn];

void Init() {
    for(int i = 0; i < maxn; ++i) {
        for(int j = 0; j <= i; ++j) {
            if(j == i || j == 0) {
                C[i][j] = 1;
            } else {
                C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
                if(C[i][j] >= MOD) {
                    C[i][j] -= MOD;
                }
            }
        }
    }
    two[0] = 1;
    for(int i = 1; i < maxn * maxn; ++i) {
        two[i] = two[i - 1] * 2;
        if(two[i] >= MOD) {
            two[i] -= MOD;
        }
    }
}

int main() {
    #ifdef Dmaxiya
    freopen("test.txt", "r", stdin);
    #endif // Dmaxiya
    ios::sync_with_stdio(false);

    Init();
    while(scanf("%d%d%d%d", &n, &m, &A, &B) != EOF) {
        ans = 0;
        for(int i = A; i <= n; ++i) {
            fa[i] = 0;
            for(int j = A; j < i; ++j) {
                fa[i] = (fa[i] + (LL)C[i][j] * fa[j]) % MOD;
            }
            fa[i] = 1 - fa[i];
            if(fa[i] < 0) {
                fa[i] += MOD;
            }
        }
        for(int i = B; i <= m; ++i) {
            fb[i] = 0;
            for(int j = B; j < i; ++j) {
                fb[i] = (fb[i] + (LL)C[i][j] * fb[j]) % MOD;
            }
            fb[i] = 1 - fb[i];
            if(fb[i] < 0) {
                fb[i] += MOD;
            }
        }
        for(int i = A; i <= n; ++i) {
            LL tmp = (LL)fa[i] * C[n][i] % MOD;
            for(int j = B; j <= m; ++j) {
                ans = (ans + ((tmp * fb[j] % MOD) * C[m][j] % MOD) * two[(n - i) * (m - j)] % MOD) % MOD;
            }
        }
        printf("%d\n", ans);
    }

    return 0;
}