POJ 1185 炮兵阵地(状态压缩DP)

 

Description

 

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

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

 

Input

 

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

 

Output

 

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

 

Sample Input

 

5 4
PHPP
PPHH
PPPP
PHPP
PHHP

 

Sample Output

 

6

 

思路:

1. 将二维地图转化为一维, map[x] == bin 存储的是一个二进制数, 表示第 x 行的地形情况, 二进制bin某一位为 0 表示平原, 1 表示高地

2. 每一行可行状态数不超过 60 个, 可以直接枚举出来, 状态的二进制表示按照递增的顺序存储到 state 数组中, 每个状态 1 的个数存储在 get 数组中

3. dp[r][i][j] 表示第 r 行的状态为 state[i], 第 r-1 行的状态为 state[j] 时的最优解(最多炮台数)

4. dp[r][i][j] = max(dp[r][i][j], dp[r-1][j][k] + get(i)) 表示 第 r 行可新增炮台数为 get(i). 但是摆放 get(i) 台炮需要满足如下条件

　　<1> state[i] & map[r] == 0 即炮台必须全部放在平原上

　　<2> state[i] & state[j] == 0 第 r, r-1 行的炮台不能放在同一列

　　<3> state[i] & state[k] == 0 第 r-1, r-2 行炮台不能放在同一列

　　<4> dp[r-1][j][k] 必须存在, 不为负无穷

 

总结:

1. 状态压缩, 要设计好二进制数位与状态的关系. 此题中, state[1][2] == 1, 含义是第 1 行的第 1 个位置处放一门炮, 这是第二种摆放方式

2. 这道题蛮难的, 状态比较多. 我没使用滚动数组, 代码看起来清晰易懂一些. 这道题值得好好总结

3. getchar 用法

4. 滚动数组回顾

 

代码:

#include <iostream>
#include <bitset>
#include <algorithm>
using namespace std;

int N, M;
const int MAXN = 110;
int map[MAXN];
int state[MAXN][MAXN], ones[MAXN][MAXN], nums[MAXN];
int dp[MAXN][MAXN][MAXN];
const int INF = 0X3F3F3F3F;

bool conflict(const int &s1, const int &s2) {
	return (s1 & s2); 
}
/*
 *	已知当前状态为 s, 能否在 pos 处摆放一门大炮
 *	由递推关系知, s 中摆放的大炮位置都在 pos 的前面
 *	s == ..1001, 表示第 1, 4 个位置上有炮台
 */
bool underAttack(const int &pos, const int s) { 
	if(pos == 0) {//首列, 肯定能放
		return false;
	}
	else if(pos == 1) {
		if(s&1)//若首列已放则第二列不能再放
			return true;
	}else if(pos >= 2) {
		if(s & (1<<(pos-1)))//倒数第一列有没有放
			return true;
		if(s & (1<<(pos-2)))//倒数第二列有没有放
			return true;
	}
	return false;
}

/*
 *	枚举第 line 行摆放大炮的可行方案并统计每种方案下的大炮数目
 *	cs, line 是全局变量, 就不需要通过参数传入函数了
 *      cs 记录已经有多少种摆放方案
 */
int cs, line;
void enumCannon(const int &st, const int s) {
	if(st == M) {
		state[line][cs++] = s;
		return ;
	}
	if(!(map[line] & (1<<st)) && !underAttack(st, s)) { // 是平原且不在其他炮台的工具范围内
		int tmp = s;
		tmp = (s|1<<st); 
		enumCannon(st+1, s);
		enumCannon(st+1, tmp);
	}else{
		enumCannon(st+1, s);
	}
}

/*
 *	dp[1] 单独初始化
 *	dp[r][i][j], i, j 都是排列的 index, 而不是状态本身, 这样就能保证 i, j < 60
 */
void pre_process() {
	// 初始化 state 数组
	for(line = 1; line <= N; line ++) {
		cs = 0;
		enumCannon(0, 0);
		sort(state[line], state[line]+cs);
		nums[line] = cs;
		for(int i = 0; i < cs; i ++) {
			bitset<10> bs(state[line][i]);
			ones[line][i] = bs.count(); // ones 记录有多少个炮台
		}
	}
	// 对第 0 行的炮台进行初始化
	memset(state[0], 0, sizeof(state[0]));
	memset(ones[0], 0, sizeof(ones[0]));
	nums[0] = 60;
	//	dp[1]初始化, 没有任何限制, 随便摆
	for(int i = 0; i < nums[1]; i ++) {
		for(int j = 0; j < nums[0]; j++) {
			dp[1][i][j] = ones[1][i]; // 能放多少放多少, 不需要考虑前几行对当前行的影响
		}						
	}
}
/*
 *	i, j, k 分别是指 dp[i][j][k], i 表示行, j 比较第 i 行有可能可行的炮台摆放方案索引, k 是第 i-1 行的摆放方案
 *	dp[i-1][k][s] 是已知
 */
int mainFunc() {
	for(int i = 2; i <= N; i ++) {
		for(int j = 0; j < nums[i]; j ++) {
			for(int k = 0; k < nums[i-1]; k ++) {
				if(conflict(state[i][j], state[i-1][k])) // i, i-1 行方案冲突
					continue;
				for(int s = 0; s < nums[i-2]; s ++) {    // i, i-2 行方案是否冲突
					if(conflict(state[i][j], state[i-2][s]))
						continue;
					dp[i][j][k] = max(dp[i][j][k], dp[i-1][k][s]+ones[i][j]);
				}
			}
		}
	}
	int ans = 0;
	if(N == 1) {
		for(int i = 0; i < nums[N]; i ++) {
			ans = max(ans, dp[N][i][0]);
		}
		return ans;
	}
	for(int i = 0; i < nums[N]; i ++) {
		for(int j = 0; j < nums[N-1]; j++) {
			ans = max(ans, dp[N][i][j]);
		}
	}
	return ans;
}
int main() {
	freopen("E:\\Copy\\ACM\\poj\\1185\\in.txt", "r", stdin);
	while(cin >> N >> M) {
		for(int i = 1; i <= N; i ++) {
			char c;
			getchar();
			for(int j = 0; j < M; j ++) { // 从左往右压
				scanf("%c", &c);
				if(c == 'H')
					map[i] = (map[i]|(1<<j)); // 技巧
			}
		}
		pre_process();
		cout << mainFunc() << endl;
	}
	return 0;
}