Poj-1185 & Nyoj-81 炮兵阵地 （状态压缩动态规划经典题

炮兵阵地

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 17815		Accepted: 6848

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

Source

总结一下题目:n行m列格子，可以看作地图，以字母P和H来标识平原和山地，每块平原上可部署一队炮兵，每队炮兵可以攻击到其上下、左右各两格远。现要在这块地图上进行部署，在保证炮兵之间不误伤的前提下，最多能部署多少部队.

解题方法：

首先，通过find_all_state()函数找出所有可能的行状态，存储在stste[]数组中，同时可以记录每种状态所包含的部队数存入stn[]数组。

之后输入地图状态，以二进制保存到rem[]数组中，山地记为1。

接下来考虑状态转移。由于炮兵会对相邻的两格都有影响，所以在状态转移过程中要考虑之前两行的情况。以dp[i][j][k]来表示对于前i行，第i行选用第j种状态，第i-1行选用第k种状态时最多可部署的炮兵数。

那么dp[i][j][k]的值可以由dp[i-1][k][p]推出，即dp[i][j][k]=max{dp[i-1][k][p]+stn[j]}，前提是第i种状态与地形不冲突，且j、k、p三种状态之间也不冲突。

注意：nyoj与poj的题目不只输入方式不同，范围也有变化（n，m可能为0）

#include<cstdio>
#include<cstring>
#include<string>
#include<iostream>
using namespace std;

int state[105],stn[105];
long long int dp[105][105][105];
int n,m,rem[105];
int most,line;

void find_all_state()
{
	most=0;
	line=1<<m;
	for(int i=0;i<line;++i)
	{
		if((i&(i<<1))==0&&(i&(i<<2))==0)
		{
			state[++most]=i;
			stn[most]=0;
			for(int j=1;j<=state[most];j=(j<<1))
			{
				if(j&state[most])	++stn[most];
			}
		}
	}
}

inline bool suit(int x,int y)
{
	if((x&y)==0) return true;
	return false;
}

int main()
{
	while(cin>>n>>m)
	{
		memset(dp,0,sizeof(dp));
		memset(state,0,sizeof(state));
		memset(stn,0,sizeof(stn));
		memset(rem,0,sizeof(rem));
		find_all_state();

		for(int i=1;i<=n;++i)
		{
			string s;
			cin>>s;
			for(int j=0;j<s.size();++j)
			{
				if(s[j]=='H')	rem[i]=rem[i]|(1<<(m-j-1));//标记不可放置的位置为1
			}
		}
		int ans=-1;//最终结果
		for(int i=1;i<=most;++i)
		{
			if(suit(rem[1],state[i]))	
			{
				dp[1][i][1]=stn[i];
				if(n==1)	ans=ans>dp[1][i][1]?ans:dp[1][i][1];
			}
		}
		if(n>=2)
		{
			for(int i=1;i<=most;++i)
			{
				if(suit(rem[2],state[i]))
				{
					for(int j=1;j<=most;++j)
					{
						if(suit(state[i],state[j]))
						{
							dp[2][i][j]=dp[2][i][j]>dp[1][j][1]+stn[i]?dp[2][i][j]:dp[1][j][1]+stn[i];
							if(n==2)	ans=ans>dp[2][i][j]?ans:dp[2][i][j];
						}
					}
				}
			}
		}
		for(int i=3;i<=n;++i)//对于第i行
		{
			for(int j=1;j<=most;++j)//当第i行取第j种状态
			{
				if(!suit(state[j],rem[i]))	continue;//若j与实际情况冲突
				
				for(int k=1;k<=most;++k)//第i-1行取第k种状态
				{
					if(!suit(state[j],state[k]))	continue;//若k与j冲突

					for(int l=1;l<=most;++l)//第i-2行取第l种状态
					{
						if(!suit(state[j],state[l]))	continue;//l不能与j冲突
						if(!suit(state[k],state[l]))	continue;//l不能与k冲突

						dp[i][j][k]=dp[i][j][k]>dp[i-1][k][l]+stn[j]?dp[i][j][k]:dp[i-1][k][l]+stn[j];

						if(i==n)	ans=ans>dp[i][j][k]?ans:dp[i][j][k];
					}
				}
			}
		}
		cout<<ans<<endl;
	}
	return 0;
}