LOJ #2731. 「JOISC 2016 Day 1」棋盘游戏（dp）
题意
JOI 君有一个棋盘，棋盘上有 \(N\) 行 \(3\) 列 的格子。JOI 君有若干棋子，并想用它们来玩一个游戏。初始状态棋盘上至少有一个棋子，也至少有一个空位。
游戏的目标是：在还没有放棋子的格子上依次放棋子，并填满整个棋盘。在某个格子上放置棋子必须满足以下条件之一：
- 这个格子的上下一格都放有棋子；
- 这个格子的左右一格都放有棋子。
JOI 君想知道有多少种从初始状态开始，并达到游戏目标的方案，这个答案可能会非常大。请你帮 JOI 君算出这个答案，并对 \(10^9+7\) 取模。
数据范围
对于所有数据，满足 \(1 \le N \le 2000\)。
题解
思维能力为 \(0\) 的 sb 帮你把 doe 的讲解搬过来啦。
显然对于每个 \(x\) 的联通块是可以单独考虑的。
首先把无解的情况全部判掉，例如有两个 \(x\) 连在一起就不行，或者 \(x\) 在四个角落也是不行的。
那么我们的联通块的形状就形如：
x x x x
xxxxxxxxx
x x x
不难发现中间一行是一定连贯的，两边会不定时的出现 \(0/1/2\) 个空。
那么我们可以对于每个中间位进行考虑，因为上下位都是可以随时填进来的。
那么满足这个节点能填的方案只有，要么上下填了，要么左右填了，要么两个都填了。
这样的话我们可以设一个 \(f[i][j][0/1]\) 表示对于第 \(i\) 列中间空，它是在整个联通块第 \(j\) 个被填进去的，在它之前满足了 上下/左右 已经填好的方案数。
注意对于上下左右都填好的时候我们为了不算重，算到上下那里去。
然后对于转移，我们第 \(i\) 列如果选上下，那么 \(i + 1\) 列上下填是不会限制的，但是对于左右填要强制 \(i\) 列中间出现在 \(i + 1\) 列之前。
\(i\) 如果选左右，那么 \(i + 1\) 列不能选左右，只能选上下，并且要强制 \(i + 1\) 列出现在 \(i\) 列之前。
然后在联通块结束的时候用组合数算算方案就行了。
然后直接转移是 \(\mathcal O(n^3)\) 的，由于只有相对的大小关系才有意义，可以前缀和优化到 \(\mathcal O(n^2)\) 。
总结
对于填的方案计数，如果相关元素不多，我们通常可以考虑 \(i\) 填在全局第 \(j\) 个的方案数，然后转移的时候乘上一个排列/组合数就好了。
代码
具体转移的细节在代码中，可以参考。
#include <bits/stdc++.h>
#define For(i, l, r) for (register int i = (l), i##end = (int)(r); i <= i##end; ++i)
#define Fordown(i, r, l) for (register int i = (r), i##end = (int)(l); i >= i##end; --i)
#define Rep(i, r) for (register int i = (0), i##end = (int)(r); i < i##end; ++i)
#define Set(a, v) memset(a, v, sizeof(a))
#define Cpy(a, b) memcpy(a, b, sizeof(a))
#define debug(x) cout << #x << ": " << (x) << endl
using namespace std;
template<typename T> inline bool chkmin(T &a, T b) { return b < a ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a, T b) { return b > a ? a = b, 1 : 0; }
inline int read() {
int x(0), sgn(1); char ch(getchar());
for (; !isdigit(ch); ch = getchar()) if (ch == '-') sgn = -1;
for (; isdigit(ch); ch = getchar()) x = (x * 10) + (ch ^ 48);
return x * sgn;
}
void File() {
#ifdef zjp_shadow
freopen ("2731.in", "r", stdin);
freopen ("2731.out", "w", stdout);
#endif
}
const int N = 4e3 + 1e2, Mod = 1e9 + 7;
namespace Computation {
inline int fpm(int x, int power) {
int res = 1;
for (; power; power >>= 1, x = 1ll * x * x % Mod)
if (power & 1) res = 1ll * res * x % Mod;
return res;
}
inline void add(int &x, int y) { if ((x += y) >= Mod) x -= Mod; }
#define plus Plus
inline int plus(int x, int y) { return (x += y) >= Mod ? x - Mod : x; }
inline void sub(int &x, int y) { if ((x -= y) < 0) x += Mod; }
inline int dec(int x, int y) { return (x -= y) < 0 ? x + Mod : x; }
inline int mul(int x, int y) { return 1ll * x * y % Mod; }
}
using namespace Computation;
int fac[N], ifac[N];
void Math_Init(int maxn) {
fac[0] = ifac[0] = 1;
For (i, 1, maxn) fac[i] = mul(fac[i - 1], i);
ifac[maxn] = fpm(fac[maxn], Mod - 2);
Fordown (i, maxn - 1, 1) ifac[i] = mul(ifac[i + 1], i + 1);
}
inline int comb(int n, int m) {
if (n < 0 || m < 0 || n < m) return 0;
return mul(mul(fac[n], ifac[n - m]), ifac[m]);
}
inline int perm(int n, int m) {
if (n < 0 || m < 0 || n < m) return 0;
return mul(fac[n], ifac[n - m]);
}
char S[3][N];
int n, f[N][N][2];
void get_pre(int x) {
For (i, 1, n * 2) Rep (j, 2)
add(f[x][i][j], f[x][i - 1][j]);
//前缀和优化一维复杂度
}
int main () {
File();
n = read();
Rep (i, 3) scanf ("%s", S[i] + 1);
Math_Init(n * 2 + 10);
for (int i = 0; i <= 2; i += 2) For (j, 1, n)
if (S[i][j] == 'x' && (S[i][j - 1] != 'o' || S[i][j + 1] != 'o'))
return puts("0"), 0;
int ans = 1, num = 0, tot = 0;
if (S[1][1] == 'x')
get_pre(f[1][1][0] = num = 1);
For (i, 2, n) {
int cur = (S[0][i] == 'x') + (S[2][i] == 'x');
if (S[1][i] == 'x') {
if (S[1][i - 1] == 'o') {
f[i][cur + 1][0] = fac[cur];
//横竖都可转移的时候，强制转移竖的
if (cur >= 1) f[i][1][1] = fac[cur];
if (cur >= 2) f[i][2][1] = 2;
get_pre(i); num = cur + 1; continue;
}
num += cur + 1;
For (j, 1, num) {
add(f[i][j][0], mul(f[i - 1][num][0], perm(j - 1, cur)));
//两个都是竖的，两个位置无先后要求，考虑当前上下插到中间前面的方案
add(f[i][j][0], mul(dec(f[i - 1][num][1], f[i - 1][max(0, j - (cur + 1))][1]), perm(j - 1, cur)));
//这个竖，上个横，那么这个中间位要比上一列中间位先填
For (k, 1, cur) if (j + k <= num)
add(f[i][j + k][1],
mul(mul(fac[cur], comb(j + k - 1, k - 1)),
//上下在中间位之前出现的方案数 与 上下互换的方案
mul(comb(max(0, num - j - k), cur + 1 - k), f[i - 1][j][0])));
//上下在中间位之后出现的方案数 以及
//强制横的先出现，竖的出现在 0 那里统计
}
get_pre(i);
} else {
if (S[1][i - 1] == 'x')
ans = mul(mul(ans, plus(f[i - 1][num][0], f[i - 1][num][1])), comb(tot += num, num));
//把当前联通块塞到前面的方案数
ans = mul(ans, perm(tot += cur, cur));
//注意对于联通块首的上下位的方案数要单独计算
}
}
if (S[1][n] == 'x')
ans = mul(ans, mul(f[n][num][0], comb(tot += num, num)));
//最后一个联通块可能没有统计，要统计上
printf ("%d\n", ans);
return 0;
}
