hdu2167之状态压缩

题目链接：

题目大意：给你一个矩阵，让你在矩阵中找一些元素使它们加起来和最大，但是当你使用某一个元素时，那么这个元素周围的其它八个元素都不能取！

思路：当前行的状态可以由上一行推断而来，所以维护当前行和上一行即可。

需要记录上一行的状态数量，每一种的状态，和从第一行到上一行每个状态的总的元素和。

当前行的话通过dfs，求出当前行状态的个数以及每个状态下当前行的值。

之和比较上一行和当前行的状态对总得元素和进行更新。

这题需要注意的是这个输入的格式，因为每两个案例之间是有空行的，所有读取到'\0'即可

 未优化版：

#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <iomanip>
#define INF 99999999
typedef long long LL;
using namespace std;

const int MAX=1597+10;
int n,nowsize,lastsize;
int now[MAX],last[MAX];
int dp[MAX],temp[MAX],ans[MAX];
int w[16][16];
char s[MAX];

void dfs(int id,int k,int p,int sum){
	if(k>=n){now[++nowsize]=p;ans[nowsize]=sum;return;}
	dfs(id,k+2,p|(1<<k),sum+w[id][k]);
	dfs(id,k+1,p,sum);
}

void DP(){
	for(int k=1;k<=n;++k){
		nowsize=0;
		dfs(k,0,0,0);
		for(int i=1;i<=nowsize;++i)dp[i]=0;
		for(int i=1;i<=nowsize;++i){
			for(int j=1;j<=lastsize;++j){
				if(now[i] & last[j])continue;
				if(now[i] & (last[j]<<1))continue;
				if(now[i] & (last[j]>>1))continue;
				dp[i]=max(dp[i],temp[j]+ans[i]);
			}
		}
		for(int i=1;i<=nowsize;++i)temp[i]=dp[i];
		for(int i=1;i<=nowsize;++i)last[i]=now[i];
		lastsize=nowsize;
	}
}

int main(){
	int k;
	while(gets(s)){
		k=1;
		do{
			n=0;
			stringstream ss(s);
			while(ss>>w[k][n])++n;
			gets(s);
			if(s[0] == '\0')break;
			++k;
		}while(true);
		n=k;
		temp[1]=last[1]=0;
		lastsize=1;
		DP();
		int sum=0;
		for(int i=1;i<=lastsize;++i)sum=max(sum,temp[i]);
		printf("%d\n",sum);
	}
	return 0;
}

现在对其进行一定程度的优化，上面代码310ms，而优化后31ms。

优化分析：

1. 由于该正方形除了相邻之间不能选之外没有其他约束条件 
2. 所以每一行的状态以及状态数其实是一样的，所以就不用1~n行每次都求该行的状态以及状态数 
3. 只要求一边即可,然后把状态以及状态数保存好并且对于状态i,用邻接矩阵储存和状态i共存的状态 
4. 然后对于第k行第i个状态,只需要采用邻接表枚举和i共存的状态来求dp[k][i]即可 
   

/*优化分析： 
由于该正方形除了相邻之间不能选之外没有其他约束条件
所以每一行的状态以及状态数其实是一样的，所以就不用1~n行每次都求该行的状态以及状态数
只要求一边即可,然后把状态以及状态数保存好并且对于状态i,用邻接矩阵储存和状态i共存的状态
然后对于第k行第i个状态,只需要采用邻接表枚举和i共存的状态来求dp[k][i]即可 
*/
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <queue>
#include <algorithm>
#include <map>
#include <cmath>
#include <iomanip>
#define INF 99999999
typedef long long LL;
using namespace std;

const int MAX=1597+10;
int n,nowsize,size;
int dp[MAX],temp[MAX],ans[MAX],now[MAX];
int w[16][16],head[MAX];
char s[MAX];

struct Edge{
	int v,next;
	Edge(){}
	Edge(int V,int NEXT):v(V),next(NEXT){}
}edge[30000];

void Init(int N){
	n=N;
	memset(dp,0,sizeof dp);
	memset(temp,0,sizeof temp);
	memset(head,-1,sizeof head);
	size=nowsize=0;
}

void InsertEdge(int u,int v){
	edge[size]=Edge(v,head[u]);
	head[u]=size++;
}

void dfs(int k,int p){
	if(k>=n){now[++nowsize]=p;return;}
	dfs(k+2,p|(1<<k));
	dfs(k+1,p);
}

int cal(int k,int p){
	int sum=0;
	for(int i=0;i<15;++i){
		if(p & (1<<i))sum+=w[k][i];
	}
	return sum;
}

void DP(){
	dfs(0,0);
	for(int i=1;i<=nowsize;++i){//此处是优化,采用邻接表储存状态 
		for(int j=i+1;j<=nowsize;++j){
			if(now[i] & now[j])continue;
			if(now[i] & (now[j]<<1))continue;
			if(now[i] & (now[j]>>1))continue;
			InsertEdge(i,j);
			InsertEdge(j,i);
		}
	}
	for(int k=1;k<=n;++k){
		for(int i=1;i<=nowsize;++i){
			ans[i]=cal(k,now[i]);
			for(int j=head[i];j != -1;j=edge[j].next){
				dp[i]=max(dp[i],temp[edge[j].v]+ans[i]);
			}
		}
		for(int i=1;i<=nowsize;++i)temp[i]=dp[i],dp[i]=0;
	}
}

int main(){
	int k;
	while(gets(s)){
		k=1;
		do{
			n=0;
			stringstream ss(s);
			while(ss>>w[k][n])++n;
			gets(s);
			if(s[0] == '\0')break;
			++k;
		}while(true);
		Init(k);
		DP();
		int sum=0;
		for(int i=1;i<=nowsize;++i)sum=max(sum,temp[i]);
		printf("%d\n",sum);
	}
	return 0;
}