HDU - 6314：Matrix （广义容斥）（占位）

Samwell Tarly is learning to draw a magical matrix to protect himself from the White Walkers.
the magical matrix is a matrix with n rows and m columns, and every single block should be painted either black or white.
Sam wants to know how many ways to paint the matrix, satisfied that the final matrix has at least A rows, B columns was painted completely black. Cause the answer might be too big, you only need to output it modulo 998244353.

InputThere might be multiple test cases, no more than 5. You need to read till the end of input.
For each test case, a line containing four integers n,m,A,B.
1≤n,m,A,B≤3000 1≤n,m,A,B≤3000

.
OutputFor each test case, output a line containing the answer modulo 998244353.
Sample Input

3 4 1 2

Sample Output

169

题意：给N*M的空白格子染色，求至少x行，至少y列被染色的方案数。

思路：不会，占位。

#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int maxn = ;
const int MOD = ;
int n, m, A, B, ans;
int C[maxn][maxn], two[maxn * maxn];
int fa[maxn], fb[maxn];

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

int main() {
    Init();
    while(~scanf("%d%d%d%d", &n, &m, &A, &B)) {
        ans = ;
        for(int i = A; i <= n; ++i) {
            fa[i] = ;
            for(int j = A; j < i; ++j) {
                fa[i] = (fa[i] + (LL)C[i][j] * fa[j]) % MOD;
            }
            fa[i] =  - fa[i];
            if(fa[i] < ) {
                fa[i] += MOD;
            }
        }
        for(int i = B; i <= m; ++i) {
            fb[i] = ;
            for(int j = B; j < i; ++j) {
                fb[i] = (fb[i] + (LL)C[i][j] * fb[j]) % MOD;
            }
            fb[i] =  - fb[i];
            if(fb[i] < ) {
                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 ;
}