【做练习】炮兵阵地（状态压缩动态规划）

题目

总时间限制: 2000ms 内存限制: 65536kB

描述

司令部的将军们打算在NM的网格地图上部署他们的炮兵部队。一个NM的地图由N行M列组成，地图的每一格可能是山地（用"H" 表示），也可能是平原（用"P"表示），如下图。在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击范围如图中黑色区域所示：

如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它能够攻击到的区域：沿横向左右各两格，沿纵向上下各两格。图上其它白色网格均攻击不到。从图上可见炮兵的攻击范围不受地形的影响。
现在，将军们规划如何部署炮兵部队，在防止误伤的前提下（保证任何两支炮兵部队之间不能互相攻击，即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内），在整个地图区域内最多能够摆放多少我军的炮兵部队。

输入

第一行包含两个由空格分割开的正整数，分别表示N和M；
接下来的N行，每一行含有连续的M个字符(‘P’或者’H’)，中间没有空格。按顺序表示地图中每一行的数据。N <= 100；M <= 10。

输出

仅一行，包含一个整数K，表示最多能摆放的炮兵部队的数量。

样例输入

5 4
PHPP
PPHH
PPPP
PHPP
PHHP

样例输出

6

---

分析

一道动态规划题。

我们可以每行往下推。我们将一行的每一种摆放方式记为一种状态。用dp[i][j][k]表示第i行为状态j，第i-1行为状态k时， 从0到第i行（含i）的最大炮兵数量。假设第i行和第i-1行的地势分别允许状态 j 和 k，我们有以下递推关系：
d p [ i ] [ j ] [ k ] = max ⁡ q { d p [ i − 1 ] [ k ] [ q ] + n u m ( j ) ) ∣ 状 态 j , k , q 互 不 冲 突 dp[i][j][k] = {\max}_q \{ dp[i-1][k][q] +num(j)) | 状态j,k,q互不冲突 dp[i][j][k]=maxq​{dp[i−1][k][q]+num(j))∣状态j,k,q互不冲突
$$，且第i-2行允许状态q\}$$

我们让i从0到N-1迭代，让j和k和q在状态空间中迭代，迭代循环地进行动态规划，最后取 dp[N-1][j][k]中关于不同j和k的最大项即可。

但是，我们该如何记录一个状态呢？假设说，每个位置都存储一个位来表示有没有炮兵，那么将有$2^{10}$种不同的状态，而我们在最坏情况下，将会循环$100\times 2^{10}\times 2^{10}\times 2^{10}=100\times 2^{30}$ 次，这是无法忍受的！

怎么办呢？事实上，我们发现，因为炮兵之间不能互相伤害的约束，上面所述$2^{10}$种不同的状态，有很多种是不可能存在的。我们需要的仅仅是那些一行中合法的状态。我们可以缩小状态空间，从而提高算法的效率。这便是【状态压缩】。

所以，我们可以先写一个辅助程序，计算出一行（最多10个位置）合法的炮兵摆放情况。每一种摆放作为一行的一种状态。经过计算，我们发现10个位置至多有60种合法的状态，我们存储这每一种状态的炮兵摆放方式、炮兵的个数，供后面使用。为了效率，我们用一个短整型的最低10位来存放这样的状态。这样以来，循环的次数就减少为最多 $100\times 60\times 60\times 60=21600000$ 次，变得可计算了。

---

代码实现

#include<iostream>
using namespace std;

using status = short;  // 用一个用一个短整型的0-9位来表示炮兵 / 山丘在一行中摆放的情况
int N, M;

inline int Bit(status s, int i)
{
	return (s >> i) & 1;
}

// 从低到高位打印，Debug用
void PrintStat(status s)
{
	for (int i = 0; i < M; i++)
		cout << Bit(s, i);
	cout << endl;
}

/*
状态压缩，将一行的所有可能变为60种状态。
*/
int numStats; // 一行的状态数
status stats[60];  // 每种状态下的具体摆放情况。
int statCnts[60];  // 每种状态下的炮兵数量 

// 计算出所有状态
void CalculateStats()
{
	// 对起始状态进行初始化
	stats[0] = 0;
	statCnts[0] = 0;
	int cnt = 1;

	for (int i = 0; i < M; i++) {  // 最右侧的炮兵在位置i
		int oldCnt = cnt;
		for (int j = 0; j < oldCnt; j++) {
			if ((i <= 0 || Bit(stats[j], i - 1) == 0) && (i <= 1 || Bit(stats[j], i - 2) == 0)) {
				stats[cnt] = stats[j] | (1 << i);
				statCnts[cnt] = statCnts[j] + 1;
				cnt++;
			}
		}
	}

	numStats = cnt;
}



status map[100]; // Bit(map[i], j) 表示位置i,j是山丘，不可以放置炮兵
int dp[100][60][60]; // 动态规划所用数组。dp[i][j][k]表示第i行为状态j，第i-1行为状态k时，从0到i行的最大数量。

// 两个状态是否冲突
inline bool Conflict(status s1, status s2)
{
	return (s1 & s2) != 0;
}



int main()
{
	cin >> N >> M;
	CalculateStats(); // 预先计算好长度位M的行上所有的合法状态

	// 输入地图
	for (int i = 0; i < N; i++) {
		map[i] = 0;
		for (int j = 0; j < M; j++) {
			char ch;
			cin >> ch;
			if(ch != 'P') map[i] |= (1 << j);
		}
	}

	// 计算第一行
	for (int j = 0; j < numStats; j++) {
		if(Conflict(stats[j], map[0]))
			for (int k = 0; k < numStats; k++)
				dp[0][j][k] = -1; // -1 表示不可能放置， 后同
		else {
			for (int k = 0; k < numStats; k++)
				if (stats[k] == 0) dp[0][j][k] = statCnts[j];
				else dp[0][j][k] = -1;
		}
	}

	// 动态规划
	for(int i = 1; i < N; i++)
		for (int j = 0; j < numStats; j++) {
			// 冲突检查
			if (Conflict(stats[j], map[i])) {
				for (int k = 0; k < numStats; k++) 
					dp[i][j][k] = -1;
			}
			else {
				for (int k = 0; k < numStats; k++) {
					int max = 0;

					// 冲突检查
					if (Conflict(stats[j], stats[k]) || Conflict(stats[k], map[i - 1])) {
						dp[i][j][k] = -1;
						continue;
					}

					for (int q = 0; q < numStats; q++) // 枚举第i - 2行的种种可能状态q，利用dp[i-1][k][q]找最大
						if (!Conflict(stats[q], stats[j]) && !Conflict(stats[q], stats[k]) && dp[i - 1][k][q] >= 0) {
							int num = dp[i - 1][k][q] + statCnts[j];
							if (num > max) max = num;
						}
					dp[i][j][k] = max;
				}
			}
		}

	// 最后取dp[N - 1][j][k]的最大
	int max = 0;
	for(int j = 0; j < numStats; j++)
		for (int k = 0; k < numStats; k++) {
			int num = dp[N - 1][j][k];
			if (num > max) max = num;
		}

	cout << max;

	return 0;
}