题目描述

---

题目思路

棋盘类问题是一类典型的状态压缩dp问题，将0设为不摆放象棋，1设为摆放象棋。这样棋盘的每一列都可以变成01的序列。每一列有8个格子，所以每列总共有种摆放情况。为了完成递推，需要写出以下功能的预处理函数 init ( )：
一、通过输入的二进制数计算出其中1的个数，以便计算已经摆放了多少个象棋。

二、根据前一列的摆放情况，判断后一列和后两列有哪些情况是不可摆放的（因为一列的象棋最多影响后两列）。

完成以上准备后开始动态规划。建立数组，表示第列、以二进制数结尾、前一列以二进制数结尾，且总共使用了个棋子的总摆放方案数。理想状态下的状态转移方程为：

前提条件是可以摆在后一排，且可以摆在后两排，这时就需要之前的预处理进行排除。

---

我的代码

动态规划部分不得已使用了五重循环，好在每层循环次数不高并且测试数据还比较人性，最终能在规定时间内解决问题。使用位运算&时一定要加括号！否则会在if判断的时候出错。

#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
int ban1[64]; //储存对应后一列不能摆放的位置（为1则无法摆放）
int ban2[64]; //储存对应后两列不能摆放的位置
int c[64];
ll dp[101][64][64][21];
int N;
int M;
int K;
ll ans = 0;
	//预处理
void init() {
	for (int i = 0; i < 64; i++)
	{
		int tmp = 0;
		int tmp2 = 0;
		int count = 0;
		for (int j = 0; j < 6; j++)
		{
			if ((i >> j) & 1) {
				if (j + 2 < 6) {
					tmp = tmp | (1 << j + 2);
				}
				if (j - 2 >= 0) {
					tmp = tmp | (1 << j - 2);
				}
				if (j + 1 < 6) {
					tmp2 = tmp2 | (1 << j + 1);
				}
				if (j - 1 >= 0) {
					tmp2 = tmp2 | (1 << j - 1);
				}
				count++;
			}
		}
		ban1[i] = tmp;
		ban2[i] = tmp2;	
		c[i] = count;
	}
}
int main() {
	init();
	int i;
	int j;
	int k;
	int l;
	int m;
	//初始化
	cin >> N >> M >> K;
	for (i = 0; i < (1 << N); i++)
	{
		for (j = 0; j < (1 << N); j++)
		{
			for (k = 0; k < K + 1; k++)
			{
				dp[0][i][j][k] = 0;
			}
		}
	}
	dp[0][0][0][0] = 1;
	//动态规划
	for (i = 1; i <= M; i++)
	{
		for (j = 0; j < (1 << N); j++)
		{
			for (k = 0; k < (1 << N); k++)
			{
				for (l = c[j]; l < K+1; l++) {
					dp[i][j][k][l] = 0;
					if ((j & ban1[k]) == 0) {
						for (m = 0; m < (1 << N); m++) {
							if ((j & ban2[m]) == 0) {
								dp[i][j][k][l] += dp[i - 1][k][m][l - c[j]];
								dp[i][j][k][l] = dp[i][j][k][l] % 1000000007;
							}
						}
					}
				}
			}
		}
	}
	//输出答案
	for (j = 0; j < (1 << N); j++)
	{
		for (k = 0; k < (1 << N); k++)
		{
			ans += dp[M][j][k][K];
			ans = ans % 1000000007;
		}
	}
	cout << ans << endl;
	return 0;
}