比较头疼的计数题.
我们发现，放置一个棋子会使得该棋子所在的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;
}