【刷题】动态规划——状态压缩DP（棋盘类）：蒙德里安的梦想

题目链接1
题目链接2

先放横的方块，再放竖的方块。

假设横的方块已经放完了，且所有空余位置能放竖的方块，那么竖的方块只有一种放法。

因此方案数就是合法的横方块放法数。合法条件是：某列的任何两个横方块之间间隔是偶数。

状态f[i, j]表示将前i-1列横方块放好，且从第i-1列伸到第i列的横方块的状态是j的所有方案数。

用二进制数来表示j，如上图第2和5行的方块伸到第i列，那么j=01001。

接下去考虑f[i, j]如何递推求得。
对于f[i, j]，j是已经固定了的，这意味着头放在i-1列、尾放在i列的方块已经确定；而头放在i-2列，尾放在i-1列的方块还不确定，也就是f[i-1, k]。对于每个f[i, j]，都可以由若干个合法的f[i-1, k]转移而来。
问题变成已知状态j和k，如何判断他们是合法的？
1、头在i-1列的方块，不能和尾在i-2列的方块在同一行，即俩方块重叠：j & k == 0
2、i-1列的任何两个横方块之间间隔是偶数：j | k的俩个1之间的0是偶数个。
（这边不考虑i列是因为i列还要加上头在i+1列的方块。而有了j和k，第i-1列的方块已经定下来了）

若数组下标是从1开始，那么最后的答案存在f[m + 1, 0]中，即前m列已经放好，没有方块伸到m+1列。
初始化f[1][0] = 1，因为第1列只有1种摆法，不放横方块。

由于要枚举i、j、k，i从1到M，j和k都是0到2^N-1，故时间复杂度为O(M * 2^N)，大概是5 *1e7。并且还有多组测试数据，因此时间限制较紧张，可以先把能转移且合法的j和k预处理出来。

#include <iostream>
#include <vector> 
#include <cstring>
using namespace std;
const int N = 2048 + 5;
long long f[15][N];
bool even_interval[N];
vector<int> state[N];
int n, m;
int main() {
	while(~scanf("%d%d", &n, &m) && n || m) {
		for (int i = 0; i < (1 << n); i ++ ) {
			int cnt = 0; // 记录1之间0的个数 
			bool is_even = true;
			for (int j = 0; j < n; j ++ ) {
				if ((i >> j) & 1) { // 状态的第j位是否是1 
					if(cnt & 1) { // 1之间0个数是偶数 
						is_even = false;
						break;
					}
					cnt = 0;
				}
				else {
					cnt ++;
				}
			}
			if(cnt & 1) is_even = false; 
			even_interval[i] = is_even;
		}
		for (int i = 0; i < (1 << n); i ++ ) {
			state[i].clear();
			for (int j = 0; j < (1 << n); j ++ ) {
				if ((i & j) == 0 && even_interval[i | j])
					state[i].push_back(j);
			}
		}
		memset(f, 0, sizeof(f));
		f[1][0] = 1; // 第1列只有1种摆法，不放横方块。 
		for (int i = 2; i <= m + 1; i ++ ) {
			for (int j = 0; j < (1 << n); j ++ ) {
				for (auto k : state[j]) {
					f[i][j] += f[i - 1][k];
				}
			}
		}
		printf("%lld\n", f[m + 1][0]);
	}
	return 0;
}

滚动数组优化，m+1只算状态0

#include <iostream>
#include <vector> 
#include <cstring>
using namespace std;
const int N = 2048 + 5;
long long f[N], g[N];
bool even_interval[N];
vector<int> state[N];
int n, m;
int main() {
	while(~scanf("%d%d", &n, &m) && n || m) {
		for (int i = 0; i < (1 << n); i ++ ) {
			int cnt = 0; // 记录1之间0的个数 
			bool is_even = true;
			for (int j = 0; j < n; j ++ ) {
				if ((i >> j) & 1) { // 状态的第j位是否是1 
					if(cnt & 1) { // 1之间0个数是偶数 
						is_even = false;
						break;
					}
					cnt = 0;
				}
				else {
					cnt ++;
				}
			}
			if(cnt & 1) is_even = false; 
			even_interval[i] = is_even;
		}
		for (int i = 0; i < (1 << n); i ++ ) {
			state[i].clear();
			for (int j = 0; j < (1 << n); j ++ ) {
				if ((i & j) == 0 && even_interval[i | j])
					state[i].push_back(j);
			}
		}
		memset(g, 0, sizeof(g));
		g[0] = 1; // 第1列只有1种摆法，不放横方块。 
		for (int i = 2; i <= m; i ++ ) {
			for (int j = 0; j < (1 << n); j ++ ) {
				f[j] = 0;
				for (auto k : state[j]) {
					f[j] += g[k];
				}
			}
			memcpy(g, f, sizeof(f));
		}
		f[0] = 0;
		for (auto k : state[0]) {
			f[0] += g[k];
		}
		printf("%lld\n", f[0]);
	}
	return 0;
}