POJ 3254 & POJ 1185 (状态压缩DP)

POJ 3254

题目大意：给一块n*m大小的田地来种东西，每一小块只能种一颗，且相邻的块不能都种。问有多少种种地方案（不种也是一种方案）。答案模上一个给定的数。1<=n,m<=12。

（1）首先想到用一个二进制数来表示某行的种植状况，二进制位上是1代表种了，0代表没种。那么m取最大12时，只需1<<12以内的数就能表示所有状态。令dp[i][s]表示第i层，用s这种种植方法的总方案数，可以知道，由s可以推出下一层的种植方法，令下一层的状态为t，则s和t在二进制上，同一位不能都为1（相邻不能种）。若s & t ！= 0，则说明当前t方法是不可行的。同时，田上还有一些地方不能种植的，记录这个状态row，那么当前状态还要满足t & row == 0。状态转移方程为：

dp[i][t] = dp[i][t] + dp[i-1][s]; (满足t & row[i] == 0, t & s == 0)

（2）有些状态是必然不成立的，比如01100，11不能相邻。所以可以提前先筛选出合法的状态，既在1<<m以内，筛选出形如0001,0101..这样的状态。筛选方法为 ：若i & (i<<1) == 0，则 i 为合法状态。

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define mod 100000000
using namespace std;

int n,m;
int fit[16];
int state[256],idx;
int dp[16][256];

void init()  //筛选出合法状态
{
	int total = 1<<m;
	idx = 0;
	for(int i=0; i<total; i++)
		if(!(i&(i<<1)))
			state[++idx] = i;
}
int main()
{
	while(~scanf("%d%d",&n,&m))
	{
		init();
		for(int i=1; i<=n; i++)
		{
			fit[i] = 0;
			for(int j=1; j<=m; j++)
			{
				int x;
				scanf("%d",&x); //当前位置不能种，将该位标记为1
				if(!x) fit[i] += (1<<(j-1));
			}
		}
		memset(dp,0,sizeof(dp));
		for(int i=1; i<=idx; i++)  //计算出第一层可以种植的方案
			if(!(fit[1] & state[i])) //该状态要满足不种在不能种的位置上
				dp[1][i] = 1;
		for(int i=2; i<=n; i++)
		{
			for(int s=1; s<=idx; s++)
			{
				if(fit[i] & state[s]) //找出能在第i行种植的状态
					continue;
				for(int k=1; k<=idx; k++)
				{
					if(state[s] & state[k]) //该状态要和上一层的状态相容，既满足相邻的不种
						continue;
					dp[i][s] = (dp[i][s] + dp[i-1][k]) % mod;
				}
			}
		}
		int ans = 0;
		for(int i=1; i<=idx; i++)
			ans = (ans + dp[n][i]) % mod;
		printf("%d\n",ans);
	}
	return 0;
}

 

POJ 1185

这题与上题类似，只不过不是相邻不能放到一起，而是必须相隔两个以上。所以对dp增加一维，既dp[i][j][k]表示第i层的状态为j，上一层的状态为k时的最大个数。同样，每一层都有一些位置是不能放炮兵的，所以记录每一层的初始状态row[i],所以有：

dp[i][j][k] = max(dp[i][j][k], dp[i-1][k][t] + num[j]);其中row[i]&state[j] == 0 && state[j] & state[k] == 0 && state[j] & state[t] == 0。同时还要保证dp[i-1][k][t]是合法的。num[j]为状态j含有的1的个数。1代表在该位置上放置了一个炮兵。

row[i]&state[j]==0表示只在该行上能放置的地方放;

state[j]&state[k]==0表示当前状态不能和上一层状态在同一位上都放置；

state[j]&state[t]==0表示当前状态不能和上两层状态在同一位上都放置

state[]跟上一题一样，可以预先筛选出来，既i&(i<<1)==0 && i&(i<<2)==0。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

int n,m;
int row[16];
int state[256],num[256],idx;
char maze[128][16];
int dp[128][256][256];

int getOne(int x) //统计该状态上1的个数，既放的炮兵数
{
	int ret = 0;
	while(x)
	{
		if(x & 1) ret ++;
		x >>= 1;
	}
	return ret;
}
void init()  //筛选出合法状态
{
	int total = 1<<m;
	idx = 0;
	for(int i=0; i<total; i++)
		if(!(i&(i<<1)) && !(i&(i<<2)))
			state[++idx] = i, num[idx] = getOne(i);
}
int main()
{
	while(~scanf("%d%d",&n,&m))
	{
		init();
		getchar();
		for(int i=1; i<=n; i++)
		{
			row[i] = 0;
			for(int j=1; j<=m; j++)
			{
				scanf("%c",&maze[i][j]);
				if(maze[i][j] == 'H')
					row[i] += (1<<(j-1)); //记录每一行的初始状态，既哪些位置不可放
			}
			getchar();
		}
		memset(dp,-1,sizeof(dp)); //初始化为-1，表示不合法
		for(int i=1; i<=idx; i++) //记录第一行在i状态下能放多少个
			if(!(row[1] & state[i])) //判断该状态是否会放在了不能放的位置，若没有，则这状态是可行的
				dp[1][i][1] = num[i];
		for(int i=2; i<=n; i++)
		{
			for(int s=1; s<=idx; s++)
			{
				if(row[i] & state[s]) //去除会放在不能放的位置的状态
					continue;
				for(int j=1; j<=idx; j++)
				{
					if(state[j] & state[s]) //找出与当前状态相容的上一层的状态
						continue;
					for(int k=1; k<=idx; k++)
					{
						if(state[k] & state[s]) //找出与当前状态相容的上两层状态
							continue;
						if(dp[i-1][j][k] == -1) //上一层必须是合法的，既i-1的状态要和i-3的相容
							continue;
						dp[i][s][j] = max(dp[i][s][j],dp[i-1][j][k]+num[s]);
					}
				}
			}
		}
		int ans = 0;
		for(int i=1; i<=n; i++)
			for(int j=1; j<=idx; j++)
				for(int k=1; k<=idx; k++)
					ans = max(ans,dp[i][j][k]);
		printf("%d\n",ans);
	}
	return 0;
}