BZOJ 3294: [Cqoi2011]放棋子 计数 + 容斥 + 组合

比较头疼的计数题.
我们发现，放置一个棋子会使得该棋子所在的1个行和1个列都只能放同种棋子.
定义状态 $f_{i,j,k}$ 表示目前已使用了 $i$ 个行，$j$ 个列，并放置了前 $k$ 种棋子的方案数.
假设当前枚举到的是第 $k$ 个棋子，该种棋子有 $num_{k}$ 个.
枚举 $d1,d2$ 表示安排这 $num_{k}$ 个棋子需要用 $d1$ 个行，$d2$ 个列.
可以将 $d1$ 个行和 $d2$ 个列并到一起，这就构成了一个 $d1\times d2$ 的矩形.
在这个矩形中要选取 $num_{k}$ 个棋子，且 $d1$ 个行和 $d2$ 个列中每一个行和列都至少要有一个棋子.
我们像要求这个东西的方案数.
分析到这步就卡住了，我想的递推式不够优秀.
同届神犇 $JZYshurak$ 给了一个容斥的解决方案 :
令 $g_{i,j,k}$ 表示在 $i\times j$ 的矩阵中安放第 $k$ 种颜色，且每个行和列都有棋子的方案数.
正着求不好求，考虑容斥：$C_{i\times j}^{num_{k}}-\sum_{x=1}^{i}\sum_{y=1}^{j}C_{i}^{x}\times C_{j}^{y}\times g_{x,y,k}$.
这个容斥的意义： 总的方案 - 不合法方案.
那么不合法方案就是 $num_{k}$ 个棋子覆盖的行和列都小于 $i$ 与 $j$ 的方案总和，还要乘一下组合数，因为矩形是我们拼凑的，实际中这个矩形的行和列都是散落的.
综上，$f_{i,j,k}=f_{i-d1,j-d2,k-1}\times C_{n-i+d1}^{d1}\times C_{m-j+d2}^{d2}\times g_{d1,d2,k}$.
时间复杂度为 $O(cn^2m^2)$

#include <cstdio>
#include <algorithm>
#define N 33
#define mod 1000000009
#define ll long long
#define setIO(s) freopen(s".in" , "r" , stdin)
using namespace std;
int num[N], n , m, c;
ll f[N][N][13], fac[1000], inv[1000], G[N][N][10];
inline ll qpow(ll base, ll k)
{
    ll tmp = 1ll;
    for( ; k ; base = (base * base) % mod , k >>= 1) if(k & 1) tmp = (tmp * base) % mod;
    return tmp;
}
inline ll C(int a, int b)
{
    return fac[a] * inv[b] % mod * inv[a - b] % mod;
}
inline void init()
{
    int i , j;
    f[0][0][0] = 1ll;
    fac[0] = inv[0] = 1;
    for(i = 1; i <= n * m ; ++ i)
    {
        fac[i] = (fac[i - 1] * i) % mod ;
        inv[i] = qpow(fac[i] , mod - 2);
    }
}
inline void Getg()
{
    int i , j , k , x, y;
    for(k = 1; k <= c; ++ k)
    {
        for(i = 1; i <= n ; ++ i)
        {
            for(j = 1; j <= m ; ++ j)
            {
                if(i * j < num[k]) continue;
                G[i][j][k] = C(i * j , num[k]);
                for(x = 1; x <= i ; ++ x)
                {
                    for(y = 1; y <= j ; ++ y)
                    {
                        if(x * y < num[k] || (x == i && y == j)) continue;
                        G[i][j][k] = (G[i][j][k] - (C(i, x) * C(j, y) % mod * G[x][y][k] % mod) + mod) % mod;
                    }
                }
            }
        }
    }
}
inline int up(int a, int b)
{
    if(a % b == 0) return a / b;
    else return (a / b) + 1;
}
int main()
{
    int i , j ,  k;
    ll re = 0;
    scanf("%d%d%d",&n , &m , &c);
    for(i = 1; i <= c ; ++ i) scanf("%d", &num[i]);
    init(), Getg();
    for(k = 1; k <= c ; ++ k)
    {
        for(i = 1; i <= n ; ++ i)
            for(j = 1; j <= m ; ++ j)
            {
                int d1, d2;
                for(d1 = 1; d1 <= num[k]; ++ d1)
                {
                    if(d1 > i) break;
                    for(d2 = up(num[k], d1); d2 <= num[k]; ++ d2)
                    {
                        if(d2 > j) break;
                        ll t = f[i - d1][j - d2][k - 1] * C(n - i + d1, d1) % mod * C(m - j + d2, d2) % mod * G[d1][d2][k] % mod;
                        f[i][j][k] = (f[i][j][k] + t) % mod;
                    }
                }
                if(k == c)
                {
                    re = (re + f[i][j][k]) % mod;
                }
            }
    }
    printf("%lld\n", re);
    return 0;
}