POJ - 2411 Mondriaan‘s Dream（状态压缩DP+DFS爆搜）

POJ - 2411

1. 所谓的状态压缩DP，就是用二进制数保存状态。为什么不直接用数组记录呢？因为用一个二进制数记录方便作位运算。

2. 本题等价于找到所有横放 1 X 2 小方格的方案数，因为所有横放确定了，那么竖放方案是唯一的。

3. 用f[i][j]记录第i列第j个状态。j状态位等于1表示上一列有横放格子，本列有格子捅出来。转移方程很简单，本列的每一个状态都由上列所有“合法”状态转移过来f[i][j] += f[i - 1][k]

4. 两个转移条件： i 列和 i - 1列同一行不同时捅出来 ； 本列捅出来的状态j和上列捅出来的状态k求或，得到上列是否为奇数空行状态，奇数空行不转移。

5. 初始化条件f[0][0] = 1，第0列只能是状态0，无任何格子捅出来。返回f[m][0]。第m + 1列不能有东西捅出来。

作者：sjytker 链接：https://www.acwing.com/solution/content/5121/

#include<iostream>
#include<cstring>
using namespace std;
const int N = 12, M = 1 << N;
int st[M];
long long f[N][M];
int main() 
{
	int n, m;
	while (cin >> n >> m && (n || m)) 
	{
		for (int i = 0; i < 1 << n; i ++) 
		{
			int cnt = 0;
			st[i] = true;
			for (int j = 0; j < n; j ++)
				if (i >> j & 1) 
				{
					if (cnt & 1) st[i] = false; // cnt 为当前已经存在多少个连续的0
					cnt = 0;
				} 
				else cnt ++;
			if (cnt & 1) st[i] = false; // 扫完后要判断一下最后一段有多少个连续的0
		}
		memset(f, 0, sizeof f);
		f[0][0] = 1;
		for (int i = 1; i <= m; i ++)
			for (int j = 0; j < 1 << n; j ++)
				for (int k = 0; k < 1 << n; k ++)
					if ((j & k) == 0 && (st[j | k]))
						// j & k == 0 表示 i 列和 i - 1列同一行不同时捅出来
						// st[j | k] == 1 表示 在 i 列状态 j， i - 1 列状态 k 的情况下是合法的.
						f[i][j] += f[i - 1][k];
		cout << f[m][0] << endl;
	}
	return 0;
}

DFS爆搜

定义状态

dp[i][j]表示前i - 1列的方格都已完全覆盖，第i列方格被第i - 1列伸出的方块覆盖后状态为j的所有方案数

例如，上图表示的就是dp[3][010010]的状态（红色为2 * 1方块，绿色为1 * 2方块）0表示没有覆盖，1表示覆盖

状态转移

我们采用由底至上的递推方式，即由当前状态推出下一列状态的方案数

以某一列的状态而言

1. 如果当前行的格子已被上一列伸出的方块覆盖，则跳过

2. 如果当前行的格子未被覆盖，说明可以放一个1 * 2的方块

3. 如果当前行的格子和下一行的格子都未被覆盖，说明可以放一个2 * 1的方块

4. 此列所有行的格子都覆盖完后，我们便可以得出下一列的合法状态

如上图，我们对第3列的状态进行搜索后可到达的其中一种状态

为什么使用搜索？

根据dp数组的定义可知，第一列不可能被上一列伸出的方块覆盖，所以初始化为dp[1][000] = 1，搜索下一列可得：

可知第二列可到达的状态只有3种，于是进行第三列的搜索时只需从这3种状态开始dfs，当前阶段总是影响下一阶段，我们只对可到达的进行讨论，并不需要枚举每一种情况

以下是DFS搜索的代码，附详细注释

void dfs(int row, int col, int state, int next) {
    //row为当前行，col为当前列，state为当前列的状态，next为可到达的下一列的状态
    //当前列全覆盖后可到达的下一个状态加上当前状态的方案数
    if (row == n) {
        //当前列所有行都已覆盖完毕
        dp[col + 1][next] += dp[col][state];
        return;
    }
    //如果当前行的格子已被覆盖，跳过
    if (state & (1 << row)) dfs(row + 1, col, state, next);
    else {
        //当前行未被覆盖，可放一个1*2的方块
        dfs(row + 1, col, state, next | (1 << row));
        //当前行和下一行都未被覆盖，可放一个2*1的方块
        if (row + 1 < n && (state & (1 << (row + 1))) == 0) dfs(row + 2, col, state, next);
    }
}

完整代码

#include<iostream> 
#include<cstdio>
#include<cstring>
using namespace std;
int n, m;
long long dp[12][2500];
void dfs(int row, int col, int state, int next) {
    //row为当前行，col为当前列，state为当前列的状态，next为可到达的下一列的状态
    //当前列全覆盖后可到达的下一个状态加上当前状态的方案数
    if (row == n) {
        //当前列所有行都已覆盖完毕
        dp[col + 1][next] += dp[col][state];
        return;
    }
    //如果当前行的格子已被覆盖，跳过
    if (state & (1 << row)) dfs(row + 1, col, state, next);
    else {
        //当前行未被覆盖，可放一个1*2的方块
        dfs(row + 1, col, state, next | (1 << row));
        //当前行和下一行都未被覆盖，可放一个2*1的方块
        if (row + 1 < n && (state & (1 << (row + 1))) == 0) dfs(row + 2, col, state, next);
    }
}
int main()
{
    while (scanf("%d%d", &n, &m) && n && m) {
        if (n > m) swap(n, m);
        //因为n行m列和n列m行的方案数等价，所以我们不妨将min(n, m)作为二进制枚举的指数，减少方案数
        memset(dp, 0, sizeof(dp));
        dp[0][0] = 1;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < (1 << n); j++) {
                if (dp[i][j] > 0) {     //筛选出之前搜索过可到达的状态
                    dfs(0, i, j, 0);
                }
            }
        }
        //因为下标从0开始，所以dp[m][0]表示第m + 1列没有任何第m列的方块伸出的方案数
        cout << dp[m][0] << endl;
    }
    return 0;
}

作者：慕明链接：https://www.acwing.com/solution/content/38047/