docs/dp/plug.md
有些 状压 DP 问题要求我们记录状态的连通性信息，这类问题一般被形象的称为插头 DP 或连通性状态压缩 DP．例如格点图的哈密顿路径计数，求棋盘的黑白染色方案满足相同颜色之间形成一个连通块的方案数，以及特定图的生成树计数等等．这些问题通常需要我们对状态的连通性进行编码，讨论状态转移过程中连通性的变化．
温故而知新，在开始学习插头 DP 之前，不妨先让我们回顾一个经典问题．
???+ note "例题 「HDU 1400」Mondriaan’s Dream" 题目大意：在 $N\times M$ 的棋盘内铺满 $1\times 2$ 或 $2\times 1$ 的多米诺骨牌，求方案数．
当 $n$ 或 $m$ 规模不大的时候，这类问题可以使用 状压 DP 解决．逐行划分阶段，设 $dp(i,s)$ 表示当前已考虑过前 $i$ 行，且第 $i$ 行的状态为 $s$ 的方案数．这里的状态 $s$ 的每一位可以表示这个这个位置是否已被上一行覆盖．
另一种划分阶段的方法是逐格 DP，或者称之为轮廓线 DP．$dp(i,j,s)$ 表示已经考虑到第 $i$ 行第 $j$ 列，且当前轮廓线上的状态为 $s$ 的方案数．
虽然逐格 DP 中我们的状态增加了一个维度，但是转移的时间复杂度减少为 $O(1)$，所以时间复杂度未变．我们用 $f_0$ 表示当前阶段的状态，用 $f_1$ 表示下一阶段的状态，$u = f_0(s)$ 表示当前枚举的函数值，那么有如下的状态转移方程：
if (s >> j & 1) { // 如果已被覆盖
f1[s ^ 1 << j] += u; // 不放
} else { // 如果未被覆盖
if (j != m - 1 && (!(s >> j + 1 & 1))) f1[s ^ 1 << j + 1] += u; // 横放
f1[s ^ 1 << j] += u; // 竖放
}
观察到这里不放和竖放的方程可以合并．
??? note "实现" ```cpp #include <algorithm> #include <iostream> using namespace std; constexpr int N = 11; long long f[2][1 << N], *f0, *f1; int n, m;
int main() {
while (cin >> n >> m && n) {
f0 = f[0];
f1 = f[1];
fill(f1, f1 + (1 << m), 0);
f1[0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
swap(f0, f1);
fill(f1, f1 + (1 << m), 0);
#define u f0[s]
for (int s = 0; s < 1 << m; ++s)
if (u) {
if (j != m - 1 && (!(s >> j & 3))) f1[s ^ 1 << j + 1] += u; // 横放
f1[s ^ 1 << j] += u; // 竖放或不放
}
}
}
cout << f1[0] << endl;
}
}
```
??? note "习题 「SRM 671. Div 1 900」BearDestroys"
题目大意：给定 $n\times m$ 的矩阵，每个格子有 E 或 S．
对于一个矩阵，有一个计分方案．按照行优先的规则扫描每个格子，如果这个格子之前被骨牌占据，则 skip．
否则尝试放多米诺骨牌．如果放骨牌的方向在矩阵外或被其他骨牌占据，则放置失败，切换另一种方案或 skip．
如果是 E 则优先放一个 $1\times 2$ 的骨牌，
如果是 S 则优先放一个 $2\times 1$ 的骨牌．
一个矩阵的得分为最后放的骨牌数．
问所有 $2^{nm}$ 种矩阵的得分的和．
阶段：动态规划执行的顺序，后续阶段的结果只与前序阶段的结果有关（无后效性）．很多 DP 问题可以有多种划分阶段的方式．例如在背包问题中，我们通常既可以按照物品划分阶段，也可以按照背包容量划分阶段（外层循环先枚举什么）．而在多米诺骨牌问题中，我们可以按照行、列、格子以及对角线等特征划分阶段．
轮廓线：已决策状态和未决策状态的分界线．
插头：一个格子某个方向的插头存在，表示这个格子在这个方向与相邻格子相连．
???+ note "例题 「HDU 1693」Eat the Trees" 题目大意：求用若干条回路覆盖 $N\times M$ 棋盘的方案数，有些位置有障碍．
严格来说，多条回路问题并不属于插头 DP，因为我们只需要和上面的骨牌覆盖问题一样，记录插头是否存在，然后成对的合并和生成插头就可以了．
注意对于一个宽度为 $m$ 的棋盘，轮廓线的宽度为 $m+1$，因为包含 $m$ 个上插头，和 $1$ 个左插头．注意，当一行迭代完成之后，最右边的左插头通常是不合法的状态，同时我们需要补上下一行第一个左插头，这需要我们调整当前轮廓线的状态，通常是所有状态进行左移，我们把这个操作称为滚动 roll()．
??? note "例题代码"
cpp --8<-- "docs/dp/code/plug/plug_1.cpp"
??? note "习题 「ZOJ 3466」The Hive II" 题目大意：同上题，但格子变成了六边形．
???+ note "例题 「Andrew Stankevich Contest 16 - Problem F」Pipe Layout" 题目大意：求用一条回路覆盖 $N\times M$ 棋盘的方案数．
在上面的状态表示中我们每合并一组连通的插头，就会生成一条独立的回路，因而在本题中，我们还需要区分插头之间的连通性（出现了！）．这需要我们对状态进行额外的编码．
通常的编码方案有括号表示和最小表示，这里着重介绍泛用性更好的最小表示．我们用长度 $m+1$ 的整形数组，记录轮廓线上每个插头的状态，$0$ 表示没有插头，并约定连通的插头用相同的数字进行标记．
那么下面两组编码方式表示的是相同的状态：
0 3 1 0 1 30 1 2 0 2 1我们将相同的状态都映射成字典序最小表示，例如在上例中的 0 1 2 0 2 1 就是一组最小表示．
我们用 b[] 数组表示轮廓线上插头的状态．bb[] 表示在最小表示的编码的过程中，每个数字被映射到的最小数字．注意 $0$ 表示插头不存在，不能被映射成其他值．
??? note "代码实现" ```cpp int b[M + 1], bb[M + 1];
int encode() {
int s = 0;
memset(bb, -1, sizeof(bb));
int bn = 1;
bb[0] = 0;
for (int i = m; i >= 0; --i) {
#define bi bb[b[i]]
if (!~bi) bi = bn++;
s <<= offset;
s |= bi;
}
return s;
}
void decode(int s) {
REP(i, m + 1) {
b[i] = s & mask;
s >>= offset;
}
}
```
我们注意到插头总是成对出现，成对消失的．因而 0 1 2 0 1 2 这样的状态是不合法的．合法的状态构成一组括号序列，实际中合法状态可能是非常稀疏的．
在一些 状压 DP 的问题中，合法的状态可能是稀疏的（例如本题），为了优化时空复杂度，我们可以使用哈希表存储合法的 DP 状态．对于 C++ 选手，我们可以使用 std::unordered_map，当然也可以直接手写，这样可以灵活的将状态转移函数也封装于其中．
???+ note "代码实现" ```cpp constexpr int MaxSZ = 16796, Prime = 9973;
struct hashTable {
int head[Prime], next[MaxSZ], sz;
int state[MaxSZ];
long long key[MaxSZ];
void clear() {
sz = 0;
memset(head, -1, sizeof(head));
}
void push(int s) {
int x = s % Prime;
for (int i = head[x]; ~i; i = next[i]) {
if (state[i] == s) {
key[i] += d;
return;
}
}
state[sz] = s, key[sz] = d;
next[sz] = head[x];
head[x] = sz++;
}
void roll() { REP(i, sz) state[i] <<= offset; }
} H[2], *H0, *H1;
```
上面的代码中：
MaxSZ 表示合法状态的上界，可以估计，也可以预处理出较为精确的值．Prime 一个小于 MaxSZ 的大素数．head[] 表头节点的指针．next[] 后续状态的指针．state[] 节点的状态．key[] 节点的关键字，在本题中是方案数．clear() 初始化函数，和手写邻接表类似，我们只需要初始化表头节点的指针．push() 状态转移函数，其中 d 是一个全局变量（偷懒），表示每次状态转移所带来的增量．如果找到的话就 +=，否则就创建一个状态为 s，关键字为 d 的新节点．roll() 迭代完一整行之后，滚动轮廓线．关于哈希表的复杂度分析，以及开哈希和闭哈希的不同，可以参见 《算法导论》 中关于散列表的相关章节．
???+ note "代码实现"
cpp REP(ii, H0->sz) { decode(H0->state[ii]); // 取出状态，并解码 d = H0->key[ii]; // 得到增量 delta int lt = b[j], up = b[j + 1]; // 左插头，上插头 bool dn = i != n - 1, rt = j != m - 1; // 下插头，右插头 if (lt && up) { // 如果左、上均有插头 if (lt == up) { // 来自同一个连通块 if (i == n - 1 && j == m - 1) { // 只有在最后一个格子时，才能合并，封闭回路． push(j, 0, 0); } } else { // 否则，必须合并这两个连通块，因为本题中需要回路覆盖 REP(i, m + 1) if (b[i] == lt) b[i] = up; push(j, 0, 0); } } else if (lt || up) { // 如果左、上之中有一个插头 int t = lt | up; // 得到这个插头 if (dn) { // 如果可以向下延伸 push(j, t, 0); } if (rt) { // 如果可以向右延伸 push(j, 0, t); } } else { // 如果左、上均没有插头 if (dn && rt) { // 生成一对新插头 push(j, m, m); } } }
??? note "例题代码"
cpp --8<-- "docs/dp/code/plug/plug_2.cpp"
??? note "习题 「Ural 1519」Formula 1" 题目大意：求用一条回路覆盖 $N\times M$ 棋盘的方案数，有些位置有障碍．
??? note "习题 「USACO 5.4.4」Betsy's Tours" 题目大意：一个 $N\times N$ 的方阵（$N\le 7$），求从左上角出发到左下角结束经过每个格子的路径总数．虽然是一条路径，但因为起点和终点固定，可以转化为一条回路问题．
??? note "习题 「POJ 1739」Tony's Tour" 题目大意：一个 $N\times M$ 的棋盘，求从左下角出发到右下角结束经过每个格子的路径总数，有些位置有障碍．
??? note "习题 「USACO 6.1.1」Postal Vans" 题目大意：求用一条有向回路覆盖 $4\times N$ 的棋盘的方案数，需要高精度．
??? note "习题 「HNOI 2007」神奇游乐园" 题目大意：给定一个 $n\times m$ 的网格图，每格内有一个权值，求一个任意一个回路，最大化经过的权值和．
??? note "习题 「ProjectEuler 393」Migrating ants" 题目大意：用多条回路覆盖 $n\times n$ 的方阵，每个有 $m$ 条回路的方案对答案的贡献是 $2^m$，求所有方案的贡献和．
???+ note "例题 「ZOJ 3213」Beautiful Meadow" 题目大意：一个 $N\times M$ 的方阵（$N,M\le 8$），每个格点有一个权值，求一段路径，最大化路径覆盖的格点的权值和．
本题是标准的一条路径问题，在一条路径问题中，编码的状态中还会存在不能配对的独立插头．需要在状态转移函数中，额外讨论独立插头的生成、合并与消失的情况．独立插头的生成和消失对应着路径的一端，因而这类事件不会发生超过两次（一次生成一次消失，或者两次生成一次合并），否则最终结果一定会出现多个连通块．
我们需要在状态中额外记录这类事件发生的总次数，可以将这个信息编码进状态里（注意，类似这样的额外信息在调整轮廓线的时候，不需要跟着滚动），当然也可以在 hashTable 数组的外面加维．下面的范例程序中我们选择后者．
???+ note "代码实现"
cpp REP(i, n) { REP(j, m) { checkMax(ans, A[i][j]); // 需要单独处理一个格子的情况 if (!A[i][j]) continue; // 如果有障碍，则跳过，注意这时状态数组不需要滚动 swap(H0, H1); REP(c, 3) H1[c].clear(); // c 表示生成和消失事件发生的总次数，最多不超过 2 次 REP(c, 3) REP(ii, H0[c].sz) { decode(H0[c].state[ii]); d = H0[c].key[ii] + A[i][j]; int lt = b[j], up = b[j + 1]; bool dn = A[i + 1][j], rt = A[i][j + 1]; if (lt && up) { if (lt == up) { // 在一条路径问题中，我们不能合并相同的插头． // Cannot deploy here... } else { // 有可能参与合并的两者中有独立插头，但是也可以用同样的代码片段处理 REP(i, m + 1) if (b[i] == lt) b[i] = up; push(c, j, 0, 0); } } else if (lt || up) { int t = lt | up; if (dn) { push(c, j, t, 0); } if (rt) { push(c, j, 0, t); } // 一个插头消失的情况，如果是独立插头则意味着消失，如果是成对出现的插头则相当于生成了一个独立插头， // 无论哪一类事件都需要将 c + 1． if (c < 2) { push(c + 1, j, 0, 0); } } else { d -= A[i][j]; H1[c].push(H0[c].state[ii]); d += A[i][j]; // 跳过插头生成，本题中不要求全部覆盖 if (dn && rt) { // 生成一对插头 push(c, j, m, m); } if (c < 2) { // 生成一个独立插头 if (dn) { push(c + 1, j, m, 0); } if (rt) { push(c + 1, j, 0, m); } } } } } REP(c, 3) H1[c].roll(); // 一行结束，调整轮廓线 }
??? note "例题代码"
cpp --8<-- "docs/dp/code/plug/plug_3.cpp"
??? note "习题 「BZOJ 2310」ParkII" 题目大意：$m\times n$ 的棋盘，每个格点有一个权值，求一条路径覆盖，最大化路径经过的点的权值和．
??? note "习题 「NOI 2010 Day2」旅行路线" 题目大意：$n\times m$ 的棋盘，棋盘的每个格子有一个 01 权值 T[x][y]，要求寻找一个路径覆盖，满足：
- 第 i 个参观的格点 (x, y)，满足 T\[x]\[y]= L\[i]
- 路径的一端在棋盘的边界上
求可行的方案数．
除了路径模型之外，还有一类常见的模型，需要我们对棋盘进行染色，相邻的相同颜色节点被视为连通．在路径类问题中，状态转移的时候我们枚举当前路径的方向，而在染色类问题中，我们枚举当前节点染何种颜色．在染色模型中，状态中处在相同连通性的节点可能不止两个．但总体来说依然大同小异．我们不妨来看一个经典的例题．
???+ note "例题 「UVa 10572」Black & White" 题目大意：在 $N\times M$ 的棋盘内对未染色的格点进行黑白染色，要求所有黑色区域和白色区域连通，且任意一个 $2\times 2$ 的子矩形内的颜色不能完全相同（例如下图中的情况非法），求合法的方案数，并构造一组合法的方案．
我们先考虑状态编码．不考虑连通性，那么就是 SGU 197. Nice Patterns Strike Back，不难用 状压 DP 直接解决．现在我们需要在状态中同时体现颜色和连通性的信息，考察轮廓线上每个位置的状态，二进制的每 Offset 位描述轮廓线上的一个位置，因为只有黑白两种颜色，我们用最低位的奇偶性表示颜色，其余部分示连通性．
考虑第一行上面的节点，和第一列左侧节点，如果要避免特判的话，可以考虑引入第三种颜色区分它们，这里我们观察到这些边界状态的连通性信息一定为 0，所以不需要对第三种颜色再进行额外编码．
在路径问题中我们的轮廓线是由 $m$ 个上插头与 $1$ 个左插头组成的．本题中，由于我们还需要判断当前格点为右下角的 $2\times 2$ 子矩形是否合法，所以需要记录左上角格子的颜色，因此轮廓线的长度依然是 $m+1$．
这样的编码方案中依然保留了很多冗余信息，（连通的区域颜色一定相同，且左上角的格子只需要颜色信息不需要连通性），但是因为已经用了哈希表和最小表示，对时间复杂度的影响不大，为了降低编程压力，就不再细化了．
在最多情况下（例如第一行黑白相间），每个插头的连通性信息都不一样，因此我们需要 $4$ 位二进制位记录连通性，再加上颜色信息，本题的 Offset 为 $5$ 位．
???+ note "代码实现" ```cpp constexpr int Offset = 5, Mask = (1 << Offset) - 1; int c[N + 2]; int b[N + 2], bb[N + 3];
T_state encode() {
T_state s = 0;
memset(bb, -1, sizeof(bb));
int bn = 1;
bb[0] = 0;
for (int i = m; i >= 0; --i) {
#define bi bb[b[i]]
if (!~bi) bi = bn++;
s <<= Offset;
s |= (bi << 1) | c[i];
}
return s;
}
void decode(T_state s) {
REP(i, m + 1) {
b[i] = s & Mask;
c[i] = b[i] & 1;
b[i] >>= 1;
s >>= Offset;
}
}
```
因为需要构造任意一组方案，这里的哈希表我们需要添加一组域 pre[] 来记录每个状态在上一阶段的任意一个前驱．
???+ note "代码实现" ```cpp constexpr int Prime = 9979, MaxSZ = 1 << 20;
template <class T_state, class T_key>
struct hashTable {
int head[Prime];
int next[MaxSZ], sz;
T_state state[MaxSZ];
T_key key[MaxSZ];
int pre[MaxSZ];
void clear() {
sz = 0;
memset(head, -1, sizeof(head));
}
void push(T_state s, T_key d, T_state u) {
int x = s % Prime;
for (int i = head[x]; ~i; i = next[i]) {
if (state[i] == s) {
key[i] += d;
return;
}
}
state[sz] = s, key[sz] = d, pre[sz] = u;
next[sz] = head[x], head[x] = sz++;
}
void roll() { REP(ii, sz) state[ii] <<= Offset; }
};
hashTable<T_state, T_key> _H, H[N][N], *H0, *H1;
```
有了上面的信息，我们就可以容易的构造方案了．首先遍历当前哈希表中的状态，如果连通块数目不超过 $2$，那么统计进方案数．如果方案数不为 $0$，我们倒序用 pre 数组构造出方案，注意每一行的末尾因为我们执行了 Roll() 操作，颜色需要取 c[j+1]．
???+ note "代码实现"
cpp void print() { T_key z = 0; int u; REP(i, H1->sz) { decode(H1->state[i]); if (*max_element(b + 1, b + m + 1) <= 2) { z += H1->key[i]; u = i; } } cout << z << endl; if (z) { DWN(i, n, 0) { B[i][m] = 0; DWN(j, m, 0) { decode(H[i][j].state[u]); int cc = j == m - 1 ? c[j + 1] : c[j]; B[i][j] = cc ? 'o' : '#'; u = H[i][j].pre[u]; } } REP(i, n) puts(B[i]); } puts(""); }
我们记：
cc 当前正在染色的格子的颜色lf 左边格子的颜色up 上边格子的颜色lu 左上格子的颜色我们用 $-1$ 表示颜色不存在．接下来讨论状态转移，一共有三种情况，合并，继承与生成：
???+ note "状态转移 - 代码"
cpp void trans(int i, int j, int u, int cc) { decode(H0->state[u]); int lf = j ? c[j - 1] : -1, lu = b[j] ? c[j] : -1, up = b[j + 1] ? c[j + 1] : -1; // 没有颜色也是颜色的一种！ if (lf == cc && up == cc) { // 合并 if (lu == cc) return; // 2x2 子矩形相同的情况 int lf_b = b[j - 1], up_b = b[j + 1]; REP(i, m + 1) if (b[i] == up_b) { b[i] = lf_b; } b[j] = lf_b; } else if (lf == cc || up == cc) { // 继承 if (lf == cc) b[j] = b[j - 1]; else b[j] = b[j + 1]; } else { // 生成 if (i == n - 1 && j == m - 1 && lu == cc) return; // 特判 b[j] = m + 2; } c[j] = cc; if (!ok(i, j, cc)) return; // 判断是否会因生成封闭的连通块导致不合法 H1->push(encode(), H0->key[u], u); }
对于最后一种情况需要注意的是，如果已经生成了一个封闭的连通区域，那么我们不能再使用她的颜色染色，否则这种颜色会出现两个连通块．我们似乎需要额度记录这种事件，可以参考 「ZOJ 3213」Beautiful Meadow 中的做法，再开一维记录这个事件．不过利用本题的特殊性，我们也可以特判掉．
???+ note "特判 - 代码"
cpp bool ok(int i, int j, int cc) { if (cc == c[j + 1]) return true; int up = b[j + 1]; if (!up) return true; int c1 = 0, c2 = 0; REP(i, m + 1) if (i != j + 1) { if (b[i] == b[j + 1]) { // 连通性相同，颜色一定相同 assert(c[i] == c[j + 1]); } if (c[i] == c[j + 1] && b[i] == b[j + 1]) ++c1; if (c[i] == c[j + 1]) ++c2; } if (!c1) { // 如果会生成新的封闭连通块 if (c2) return false; // 如果轮廓线上还有相同的颜色 if (i < n - 1 || j < m - 2) return false; } return true; }
进一步讨论连通块消失的情况．每当我们对一个格子进行染色后，如果没有其他格子与其上侧的格子连通，那么会形成一个封闭的连通块．这个事件仅在最后一行的最后两列时可以发生，否则后续为了不出现 $2\times 2$ 的同色连通块，这个颜色一定会再次出现，除了下面的情况：
2 2
o#
#o
我们特判掉这种情况，这样在本题中，就可以偷懒不用记录之前是否已经生成了封闭的连通块了．
??? note "例题代码"
cpp --8<-- "docs/dp/code/plug/plug_4.cpp"
??? note "习题 「Topcoder SRM 312. Div1 Hard」CheapestIsland" 题目大意：给一个棋盘图，每个格子有权值，求权值之和最小的连通块．
??? note "习题 「JLOI 2009」神秘的生物" 题目大意：给一个棋盘图，每个格子有权值，求权值之和最大的连通块．
??? note "习题 「AtCoder Beginner Contest 211. Problem E」Red Polyomino" 题目大意：给一个 $N\times N$ 大小的棋盘图，每个格子初始为黑色或白色．你可以从白色格子中挑选恰好 $K$ 个并将之染成红色，问有多少种染色方案满足红色格子形成一个连通块．
???+ note "例题 「NOI 2007 Day2」生成树计数" 题目大意：某类特殊图的生成树计数，每个节点恰好与其前 $k$ 个节点之间有边相连．
???+ note "例题 「2015 ACM-ICPC Asia Shenyang Regional Contest - Problem E」Efficient Tree" 题目大意：给出一个 $N\times M$ 的网格图，以及相邻四连通格子之间的边权． 对于一颗生成树，每个节点的得分为 1+[有一条连向上的边]+[有一条连向左的边]． 生成树的得分为所有节点的得分之积．
你需要求出：最小生成树的边权和，以及所有最小生成树的得分之和．
（$n\le 800,m\le 7$）
???+ note "例题 「HDU 4113」Construct the Great Wall"
题目大意：在 $N\times M$ 的棋盘内构造一组回路，分割所有的 x 和 o．
有一类插头 DP 问题要求我们在棋盘上构造一组墙，以分割棋盘上的某些元素．不妨称之为修墙问题，这类问题既可视作染色模型，也可视作路径模型．
在本题中，如果视作染色模型的话，不仅需要额外讨论染色区域的周长，还要判断在角上触碰而导致不合法的情况（图 2）．另外与 「UVa 10572」Black & White 不同的是，本题中要求围墙为简单多边形，因而对于下面的回字形的情况，在本题中是不合法的．
3 3
ooo
oxo
ooo
因而我们使用路径模型，转化为 一条回路 来处理．
我们沿着棋盘的交叉点进行 DP（因而长宽需要增加 $1$），每次转移时，需要保证所有的 x 在回路之外，o 在回路之内．因此我们还需要维护当前位置是否在回路内部．对于这个信息我们可以加维，也可以直接统计轮廓线上到这个位置之前出现下插头次数的奇偶性（射线法）．
??? note "例题代码" ```cpp #include <cstring> #include <iostream> using namespace std; #define REP(i, n) for (int i = 0; i < n; ++i)
template <class T>
bool checkMin(T &a, const T b) {
return b < a ? a = b, true : false;
}
constexpr int N = 10, M = N;
constexpr int offset = 3, mask = (1 << offset) - 1;
int n, m;
int d;
constexpr int INF = 0x3f3f3f3f;
int b[M + 1], bb[M + 1];
int encode() {
int s = 0;
memset(bb, -1, sizeof(bb));
int bn = 1;
bb[0] = 0;
for (int i = m; i >= 0; --i) {
#define bi bb[b[i]]
if (!~bi) bi = bn++;
s <<= offset;
s |= bi;
}
return s;
}
void decode(int s) {
REP(i, m + 1) {
b[i] = s & mask;
s >>= offset;
}
}
constexpr int MaxSZ = 16796, Prime = 9973;
struct hashTable {
int head[Prime], next[MaxSZ], sz;
int state[MaxSZ];
int key[MaxSZ];
void clear() {
sz = 0;
memset(head, -1, sizeof(head));
}
void push(int s) {
int x = s % Prime;
for (int i = head[x]; ~i; i = next[i]) {
if (state[i] == s) {
checkMin(key[i], d);
return;
}
}
state[sz] = s, key[sz] = d;
next[sz] = head[x];
head[x] = sz++;
}
void roll() { REP(i, sz) state[i] <<= offset; }
} H[2], *H0, *H1;
char A[N + 1][M + 1];
void push(int i, int j, int dn, int rt) {
b[j] = dn;
b[j + 1] = rt;
if (A[i][j] != '.') {
bool bad = A[i][j] == 'o';
REP(jj, j + 1) if (b[jj]) bad ^= 1;
if (bad) return;
}
H1->push(encode());
}
int solve() {
cin >> n >> m;
int ti, tj;
REP(i, n) {
scanf("%s", A[i]);
REP(j, m) if (A[i][j] == 'o') ti = i, tj = j;
A[i][m] = '.';
}
REP(j, m + 1) A[n][j] = '.';
++n, ++m, ++ti, ++tj;
H0 = H, H1 = H + 1;
H1->clear();
d = 0;
H1->push(0);
int z = INF;
REP(i, n) {
REP(j, m) {
swap(H0, H1);
H1->clear();
REP(ii, H0->sz) {
decode(H0->state[ii]);
d = H0->key[ii] + 1;
int lt = b[j], up = b[j + 1];
bool dn = i != n - 1, rt = j != m - 1;
if (lt && up) {
if (lt == up) {
int cnt = 0;
REP(i, m + 1) if (b[i])++ cnt;
if (cnt == 2 && i == ti && j == tj) {
checkMin(z, d);
}
} else {
REP(i, m + 1) if (b[i] == lt) b[i] = up;
push(i, j, 0, 0);
}
} else if (lt || up) {
int t = lt | up;
if (dn) {
push(i, j, t, 0);
}
if (rt) {
push(i, j, 0, t);
}
} else {
--d;
push(i, j, 0, 0);
++d;
if (dn && rt) {
push(i, j, m, m);
}
}
}
}
H1->roll();
}
if (z == INF) z = -1;
return z;
}
int main() {
int T;
cin >> T;
for (int Case = 1; Case <= T; ++Case) {
printf("Case #%d: %d\n", Case, solve());
}
}
```
??? note "习题 「SCOI 2011」地板" 题目大意：$r\times c$ 的棋盘上有一些位置设置障碍，问使用 L 型的瓷砖铺满所有没有障碍的格子，有多少种方案．
??? note "习题 「HDU 4796」Winter's Coming" 题目大意：在 $N\times M$ 的棋盘内对未染色的格点进行黑白灰染色，要求所有黑色区域和白色区域连通，且黑色区域与白色区域分别与棋盘的上下边界连通，且其中黑色区域与白色区域不能相邻．每个格子有对应的代价，求一组染色方案，最小化灰色区域的代价．
??? note "习题 「ZOJ 2125」Rocket Mania"
题目大意：$9\times6$ 的地图上每个格子里是一种管道（-,T,L,+ 型或没有），可以把管道旋转 0°,90°,180°,270°, 问地图最多能有几行的右边界与第 X 行的左边界通过管道相连．
??? note "习题 「ZOJ 2126」Rocket Mania Plus"
题目大意：$9\times6$ 的地图上每个格子里是一种管道（-,T,L,+ 型或没有），可以把管道旋转 0°,90°,180°,270°, 问地图最多能有几行的右边界与左边界通过管道相连．
??? note "习题 「World Finals 2009/2010 Harbin」Channel"
题目大意：一张方格地图上用 . 表示空地、# 表示石头，找到最长的一条路径满足：
1. 起点在左上角，终点在右下角．
2. 不能经过石头．
3. 路径自身不能在八连通的意义下成环．（即包括拐角处也不能接触）
??? note "习题 「HDU 3958」Tower Defence" 题目大意：可以转化为求解一条从 $\mathit{S}$ 到 $\mathit{T}$ 的不能接触的最长路径，拐角处可以接触．
??? note "习题 「UVa 10531」Maze Statistics" 题目大意：有一个 $N\times M$ 的图，每个格子有独立概率 $\mathit{p}$ 变成障碍物．你要从迷宫左上角走到迷宫右下角．求每个格子成为一个 有解迷宫（即起点终点四联通） 中的障碍物的概率．（$N \le 5$，$M \le 6$）
??? note "习题 「Aizu 2452」Pipeline Plans" 题目大意：现有一共 12 种图案的瓷砖，每种瓷砖数量给定．要求铺到一块可视为 $R\times C$ 网格图的矩形地板上，一个格子铺一块瓷砖，且左上角格子的中心与右下角格子的中心通过瓷砖图案上的线联通．$(2 \le R \times C \le 15)$
??? note "习题 「SDOI 2014」电路板" 题目大意：一块 $N\times M$ 的电路板，上面有些位置是电线不能走的障碍，给定 $K$ 个格子对，要求每对格子都有电线相连，且电线之间互不相交（允许一条电路线从上边界进入当前格子，从左边界离开这个格子，另外一条电路线可以从下边界进入格子，从右边界出去）．视电线为无向边，求满足要求的最短电线长度和方案数．
??? note "习题 「SPOJ CAKE3」Delicious Cake" 题目大意：一块可视为 $N\times M$ 网格的蛋糕，现沿着格线将蛋糕切成数块，问有多少种不同的切割方法．切法相同当且仅当切成的每块蛋糕都形状相同且在同一位置上．（$\min(N,M) \le 5, \max(N,M) \le 130$）
插头 DP 问题通常编码难度较大，讨论复杂，因而属于 OI/ACM 中相对较为 偏门的领域．这方面最为经典的资料，当属 2008 年 陈丹琦 的集训队论文——基于连通性状态压缩的动态规划问题．其次，HDU 的 notonlysuccess 2011 年曾经在博客中连续写过两篇由浅入深的专题，也是不可多得的好资料，不过现在需要在 Web Archive 里考古．
「HDU 1400」Mondriaan’s Dream 也出现在 《算法竞赛入门经典训练指南》 中，并作为《轮廓线上的动态规划》一节的例题．多米诺骨牌覆盖（Domino tiling） 是一组非常经典的数学问题，稍微修改其数据范围就可以得到不同难度，需要应用不同的算法解决的子问题．
当限定 $m=2$ 时，多米诺骨牌覆盖等价于斐波那契数列．《具体数学》 中使用了该问题以引出斐波那契数列，并使用了多种方法得到其解析解．
当 $m\le 10,n\le 10^9$ 时，可以将转移方程预处理成矩阵形式，并使用 矩阵乘法进行加速．
当 $n,m\le 100$，可以用 FKT Algorithm 计算其所对应平面图的完美匹配数．
「一条路径」是 哈密顿路径（Hamiltonian Path） 问题在 格点图（Grid Graph） 中的一种特殊情况．哈密顿路径的判定性问题是 NP-complete 家族中的重要成员．