POJ--1038--Bugs Integrated, Inc.--状态DP

硬着头皮写了两天，下面把思路复述一下：

一：状态的表示：

对于每一行来说，ａ［ｘ］＝｛０，１，２｝；分别表示格点ｘ的上方有｛０，１，２｝个空格可用。和黑书的不一样，我觉得这样表示比较方便直观一点就这样表示了。

然后对于每一行可看做是一个三进制的数字，再把这个三进制数转换成十进制数字，从而实现状态压缩存储的目的。

二：ｄｐ　数组的表示：ｄｐ［ｉ］［ｊ］　表示从第ｉ－１行的任意状态得到的第ｉ行的　ｊ　状态，第ｉ－１能够放置的最大芯片数量，理解了这个状态表示这个题就会了～～如果你实在是理解不了，可以看一下其他人的状态表示，或者直接看代码也可以（思路在第二份有注释的代码里面）。

三：用滚动数组节省空间

下面这个没有注释的代码是在第一次写出来怎么调试都ＷＡ的情况重新写的，ＡＣ了

#include<iostream>
#include<cstring>
#include<cstdio>
#define M(a) memset((a),0,sizeof((a)))
#define maxn 160
#define maxs 60000
#define dbug1
using namespace std;
int bmp[maxn][maxn];
int n,m,bp;
int st[3][maxs];
int sc[3];
int dp[3][maxs];
int sq3[]={1,3,9,27,81,243,729,2187,6561,19683,59049};
int curStatu;
bool visStatus[maxs];
int temp_dp;

void init()
{
	int x,y;
	M(bmp);M(st);M(sc);
	scanf("%d%d%d",&n,&m,&bp);
	while(bp--)
	{
		scanf("%d%d",&x,&y);
		bmp[x][y]=1;
	}
}
void get_Status(int *pre,int u)
{
	memset(pre,0,sizeof(int)*(m+1));
	int c=m;
	while(u)
	{
		pre[c]=u%3;
		u/=3;
		c--;
	}
}
void dfs(int r,int pre[],int cl,int code,int num)
{
	if(cl>m)
	{
		if(!visStatus[code])
		{
			st[2][sc[2]++]=code;
			visStatus[code]=1;
		}
		dp[2][code]=max(dp[2][code],temp_dp+num);
	}
	else if(bmp[r][cl])
	{
		dfs(r,pre,cl+1,code,num);
	}
	else
	{
		if(cl+1<=m&&bmp[r][cl+1]==0&&pre[cl]>1&&pre[cl+1]>1)
		{
			dfs(r,pre,cl+2,code,num+1);
		}
		if(cl+2<=m&&((bmp[r][cl+1]+bmp[r][cl+2])==0)&&pre[cl]>0&&pre[cl+1]>0&&pre[cl+2]>0)
		{
			dfs(r,pre,cl+3,code,num+1);
		}
		code+=pre[cl]>0?2*sq3[m-cl]:sq3[m-cl];
		dfs(r,pre,cl+1,code,num);
	}
}
void solve()
{
	sc[1]=1;M(dp);
	int pre[12];
	
	for(int i=1;i<=n;i++)
	{
		M(visStatus);
		for(curStatu=0;curStatu<sc[1];curStatu++)
		{
			temp_dp=dp[1][st[1][curStatu]];
			get_Status(pre,st[1][curStatu]);
			dfs(i,pre,1,0,0);
		}
		for(int j=0;j<sc[2];j++)
		{
			st[1][j]=st[2][j];
		}
		sc[1]=sc[2];sc[2]=0;M(st[2]);
		M(dp[1]);
		for(int j=0;j<sc[1];j++)
		{
			dp[1][st[1][j]]=dp[2][st[1][j]];
		}
		M(dp[2]);
		#ifdef dbug
		int tans=0;
		for(int j=0;j<sc[1];j++)
		{
			tans=max(tans,dp[1][st[1][j]]);
		}
		printf("%d ---> %d\n",i,tans);
		#endif
	}
	int ans=0;
	for(int i=0;i<sc[1];i++)
	{
		ans=max(ans,dp[1][st[1][i]]);
	}	
	printf("%d\n",ans);
}


int main()
{
	#ifdef dbug
	freopen("1038.txt","r",stdin);
	#endif
	int T;
	scanf("%d",&T);
	while(T--)
	{
		init();
		solve();
	}
	return 0;
}

下面的这个代码是调试到死都过不了的代码，加了很多的注释，思路可以看一下这里。另外如果你知道这份代码哪里修改了可以过掉这题，请告诉我，谢谢。（楼主已经找到错误了。。。。）

#define dbug1
#include<iostream>
#include<cstring>
#include<cstdio>
#define maxn 120	／／这是后来楼主加的，数组开小了，尼玛。。。ＰＯＪ给ＷＡ不给ＲＥ，坑爹啊
#define maxs 60000
#define M(a) memset((a),0,sizeof((a)))
using namespace std;
int n,m;	// the height and width
int bp;		//the number if bad point
int bmp[maxn][maxn];	//the map with binary  style
int dp[3][maxs];		//dp[i][j]表示第 i 行状态为 j 时的最大放置数量 
int st[3][maxs];	//压缩存储每一行的状态 
int sc[3];			//每一行的状态数量 
int curStatu;       		//深搜时的父状态 
bool visStatu[maxs];	//记录深搜状态是否到达过 
const int sq3[]={1,3,9,27,81,243,729,2187,6561,19683,59049};
/**************** 
* 状态表示 ： pre[i] 表示当前格点的上方有几个格点是空置的
*****************/ 
void init()
{
	int x,y;
	M(bmp);M(st);M(sc);
	//data input 
	scanf("%d%d%d",&n,&m,&bp);
	while(bp--)
	{
		scanf("%d%d",&x,&y);
		bmp[x][y]=1;
	}
}
void get_statu(int pre[],int u)
{
	//将压缩后的状态 u 解压缩后存储在pre 数组返回 
	int c=m;
	memset(pre,0,sizeof(int)*12);	//此时pre是指针，而不是数组首地址,sizeof(pre)为4 
	while(u)
	{
		pre[c]=u%3;
		u/=3;
		c--;
	}
}
int temp_dp;	//存储父状态curStatu 能放置的最大芯片数量  
void dfs(int r,int pre[],int cl,int code,int num)//r 当前行，pre[]每个格点的状态 ，cl 当前列 
{						//code 当前状态压缩编码，num 表示沿父状态深搜到当前状态新增加的芯片数量 
	if(cl>m)	//深搜边界 
	{
		if(!visStatu[code]) 
		{
			visStatu[code]=1; 
			st[2][sc[2]++]=code;	//下一行的新状态 
		} 
		/*if(temp_dp+num>dp[1][st[1][curStatu]]) //更新当前行 curStatu 状态能放置的最大芯片数量 
		{
			dp[1][st[1][curStatu]]=temp_dp+num;
		}*/
		dp[2][code]=max(dp[2][code],temp_dp+num);	//此时的dp[2][code]记录的是下一行到达code状态时 													//上一行的最大放置数量
	}
	else if(bmp[r][cl])  	//坏点，不放。 
	{
		dfs(r,pre,cl+1,code,num);
	}
	else
	{
		if(cl+1<=m&&bmp[r][cl+1]==0&&pre[cl]>1&&pre[cl+1]>1)//符合放置宽为2，高为3 的芯片 
		{
			dfs(r,pre,cl+2,code,num+1);
		}
		//放置宽为3 ，高为2 的芯片 
		if(cl+2<=m&&(bmp[r][cl+1]+bmp[r][cl+2]==0)&&pre[cl]>=1&&pre[cl+1]>=1&&pre[cl+2]>=1)
		{
			dfs(r,pre,cl+3,code,num+1);
		}
		
		//当前格点，不放。 
		code+=pre[cl]>=1?2*sq3[m-cl]:sq3[m-cl];
		dfs(r,pre,cl+1,code,num);
	}
}
void solve()
{
	int pre[12],code;
	M(dp);
	sc[1]=1;	//第一行只有一种状态，上方空置格点为0
	
	//滚动数组，index=1 是当前行，index =2 是下一行 
	for(int i=1;i<=n;i++)
	{
		M(visStatu); 	//下一行的所有状态都没有出现过 
		for(curStatu=0;curStatu<sc[1];curStatu++) //当前行的状态数量，curStatu是全局变量 
		{
			get_statu(pre,st[1][curStatu]);		//状态解压缩 
			temp_dp=dp[1][st[1][curStatu]];     //temp_dp是上一行能走到当前状态的最大芯片数量 
			dfs(i,pre,1,0,0);  
		}
		
		//数组滚动操作 
		for(int j=0;j<sc[2];j++)	//状态滚啊滚，向上滚 
		{
			st[1][j]=st[2][j];
		}
		sc[1]=sc[2];sc[2]=0;M(st[2]);
		M(dp[1]);
		
		//dp 数组滚啊滚 
		for(int j=0;j<sc[1];j++)
		{
			dp[1][st[1][j]]=dp[2][st[1][j]];
		}
		
		M(dp[2]);
	}	
	//find answer 
	int ans=0;
	for(int i=0;i<sc[1];i++)
	{
		ans=max(ans,dp[1][st[1][i]]);
	}
	printf("%d\n",ans);
}
int main()
{
	freopen("1038.txt","r",stdin);
	int T;
	scanf("%d",&T);
	while(T--)
	{
		init();
		solve();
	}
	return 0;
}