POJ- 1753 + 2965（枚举+DFS）

题目：POJ-1753

题意：一个4 x 4的方格，里面有黑色和白色，问你最少多少次翻转可以让方格成为同一个颜色，每次翻转可以翻自己跟上下左右共5个方格

题解：枚举翻多少次，一个格子翻一次变成另外一个颜色，翻两次变成原来的颜色，就相当于没有进行翻转，所以本题最多翻转16次（因为某一个格子再进行一次翻转，就变成了原来的颜色，相当于没有进行翻转一样，所以那次是多余，那么就最多只有16次），枚举翻转的次数0~16次，对于每次翻转的格子进行DFS搜索枚举，列举出对于翻转i次，可能翻转的格子有哪些，判断那几次翻转是否可以，这tm就一基础题，然后我xjb进行DFS，居然还不会写，后来看到网上的用1~16表示对应的行列，翻转操作在最后check的时候进行，不可以就把原图像复原，真是太机智了，我好菜啊啊啊啊啊啊、、、这个博客更牛逼，好多种方法解决。通过这个题目让自己学到了如果用数字转化为矩阵中的行列。

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<string>
#define INF 999
using namespace std;
int a[10][10],ans;
char c;
bool vis[20];
void make()
{
	for(int i=1;i<=16;i++)
	{
		if(vis[i])
		{
			int x=i/4+1;
			int y=i%4;
			if(i%4==0)
			{
				x--;
				y=4;
			}
			a[x][y]=-a[x][y];
			a[x+1][y]=-a[x+1][y];
			a[x-1][y]=-a[x-1][y];
			a[x][y+1]=-a[x][y+1];
			a[x][y-1]=-a[x][y-1];
		}
	}
	return ;
}
bool check()
{
	for(int i=1;i<=4;i++)
		for(int j=1;j<=4;j++)
			if(a[i][j]!=a[1][1])
				return 0;				
	return 1;
}
void DFS(int num,int k,int x)
{	
	if(ans<INF)return ;
	if(k==num)
	{
		make();
		if(check())ans=num;
		else make();
		return;
	}
	for(int i=x+1;i<=16;i++)
	{
		vis[i]=1;
		DFS(num,k+1,i);
		vis[i]=0;
	}
}
int main()
{
	memset(a,0,sizeof(a));
	for(int i=1;i<=4;i++)
		for(int j=1;j<=4;j++)
		{
			cin>>c;
			if(c=='w')a[i][j]=1;
			else a[i][j]=-1;
		}
	ans=INF;
	for(int i=0;i<=16;i++)
	{
		memset(vis,0,sizeof(vis));
		DFS(i,0,0);
		if(ans!=INF)break;		
	}
	if(ans!=INF)printf("%d",ans);
	else printf("Impossible");
	return 0;
}

更新的更快的DFS+枚举的代码，就不用先枚举我当前用了多少次，直接开始搜，每进行一次新的翻转就进行一次操作，然后每次操作过后就进行check，可以节省很多时间，上一个代码253MS，这一个直接快到了63MS

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<string>
#define INF 999
using namespace std;
int a[10][10],ans;
char c;
// bool vis[20];
void make(int i)
{
	int x=i/4+1;
	int y=i%4;
	if(i%4==0)
	{
		x--;
		y=4;
	}
	a[x][y]=-a[x][y];
	a[x+1][y]=-a[x+1][y];
	a[x-1][y]=-a[x-1][y];
	a[x][y+1]=-a[x][y+1];
	a[x][y-1]=-a[x][y-1];
	return ;
}
bool check()
{
	for(int i=1;i<=4;i++)
		for(int j=1;j<=4;j++)
			if(a[i][j]!=a[1][1])
				return 0;				
	return 1;
}
void DFS(int k,int x)
{	
	if(check())
	{
		if(ans>k)
		{
			ans=k;
		}
		return ;
	}
	if(k>=16)return ;
	for(int i=x+1;i<=16;i++)
	{
		// vis[i]=1;
		make(i);
		DFS(k+1,i);
		make(i);
		// vis[i]=0;
	}
}
int main()
{
	memset(a,0,sizeof(a));
	for(int i=1;i<=4;i++)
		for(int j=1;j<=4;j++)
		{
			cin>>c;
			if(c=='w')a[i][j]=1;
			else a[i][j]=-1;
		}
	ans=INF;
	DFS(0,0);
	if(ans!=INF)printf("%d",ans);
	else printf("Impossible");
	return 0;
}

题目：POJ-2965

题意：跟上一题差不多

题解：我这个题目先用上一个题目的第一种DFS+枚举的方法，居然T了，想了好久，感觉也是最多是16次啊，为什么会T呢，最后才知道，实际上就是我之前枚举方案数的时候导致T了，如果我直接每次操作立马就进行更新，然后进行判断，可以就把方案数跟当前操作的位置记录下来，枚举所有可能的操作2^16=6W+，那么就不会T了。

代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<string>
#define INF 99999
using namespace std;
int a[105][105],ans,sumx[10005],cnt,sumy[10005];
char c;
bool vis[205];
void make(int i)
{
	int x=i/4+1;
	int y=i%4;
	if(i%4==0)
	{
		x--;
		y=4;
	}
	a[x][y]=-a[x][y];
	for(int j=1;j<=4;j++)if(j!=y)a[x][j]=-a[x][j];
	for(int j=1;j<=4;j++)if(j!=x)a[j][y]=-a[j][y];
	return;
}
bool check()
{
	for(int i=1;i<=4;i++)
		for(int j=1;j<=4;j++)
			if(a[i][j]!=1)return 0;
	return 1;
}
void take()
{
	cnt=0;
	for(int i=1;i<=16;i++)
	{
		if(vis[i])
		{
			int x=i/4+1;
			int y=i%4;
			if(i%4==0)
			{
				x--;
				y=4;
			}
			cnt++;
			sumx[cnt]=x;
			sumy[cnt]=y;
		}
	}
}
void DFS(int k,int x)//翻转到第k个，遍历到第x个
{
	if(check())
	{
		if(ans>k)
		{
			ans=k;
			take();
		}
		return ;
	}
	if(k>=16)return ;
	for(int i=x+1;i<=16;i++)
	{
		vis[i]=1;
		make(i);
		DFS(k+1,i);
		make(i);
		vis[i]=0;
	}
}
int main()
{
	memset(a,0,sizeof(a));
	for(int i=1;i<=4;i++)
		for(int j=1;j<=4;j++)
		{
			cin>>c;
			if(c=='-')a[i][j]=1;
			else a[i][j]=-1;
		}
	ans=INF;
	DFS(0,0);
	printf("%d\n",ans);
	for(int i=1;i<=cnt;i++)printf("%d %d\n",sumx[i],sumy[i]);
	return 0;
}