POJ 3279 Fliptile【状态压缩+DFS】

POJ 3279 Fliptile 【状态压缩+DFS】

题目大意：
有一个 M * N 的格子，每个格子可以翻转正反面，它们有一面是黑色，另一面是白色。黑色翻转之后变成白色，白色翻转之后则变成黑色。
任务就是把所有的格子翻转为白色。不过每次翻转一个格子，与它上下左右相邻接的格子也会被翻转。
若存在解，输出最小的翻转次数时，每个格子的翻转次数。有多个解时，输出字典序最小的一组；否认输出IMPOSSIBLE
即经过翻转后把所有的数字都为0

具体思路：
首先，基本思想是枚举，每个格子有翻转和不翻转两种选择，总共有M*N个格子，所以时间复杂度（2ⁿ*M*N）,显然这不是我们要的求解方式。接下来进行剪枝，会发现，当你先枚举了第一行之后，要想有解，下一行的翻转情况已经固定。
例如：4*4中，第一行翻转后为（1，0，1，0），要想第一行翻转后全为0，那么下一行中与1相对于的位置一定要翻转，与0相对的一定不能翻转。同理往下一行推，能够推出每一行的翻转情况，全部的翻转情况确定之后，若最后一行全为0，则每一行都为0，满足情况，若最后一行不为0，则次枚举情况不满足。此时时间复杂度为：外层枚举（2^N）*内层dfs的时间复杂度，而题目中，M和N<=15，可行

而图只有0和1两种数据，故考虑二进制状态压缩+dfs

具体代码：

#include
#include
#include
using namespace std;
int orig[15][15], test[15][15], ans[15][15], save[15][15];	
//orig是最初的图，test是每次枚举时临时保存的图，save是枚举时保存翻转次数的图，ans是最优答案保存每格翻转次数
int updown[4][2] = {
      {
     1,0},{
     -1,0},{
     0,1},{
     0,-1} };
int m, n, res = 999999;
int flag = 0;	//判断是否存在解决方案
void setZero(int arr[][15])	//初始化翻转次数
{
     
	for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++)
			arr[i][j] = 0;
}
int getCount()	//求得每次枚举后的翻转总次数
{
     
	int sum = 0;
	for (int i = 0; i < m; i++)
	{
     
		for (int j = 0; j < n; j++)
		{
     
			sum += save[i][j];
		}
	}
	return sum;
}
void copyArr(int des[][15],int res[][15])
{
     
	for (int i = 0; i < m; i++)
		for (int j = 0; j < n; j++)
			des[i][j] = res[i][j];
}
void turnOver(int a,int b,int flag)
{
     
	if (flag == 0)return;	//不翻转
	test[a][b] = test[a][b] == 0 ? 1 : 0;	//翻转自身
	save[a][b]++;
	for (int i = 0; i < 4; i++)	//翻转四周
	{
     
		int t1 = a + updown[i][0], t2 = b + updown[i][1];
		if (t1 >= 0 && t1 < m && t2 >= 0 && t2 < n) {
     
			test[t1][t2] = test[t1][t2] == 0 ? 1 : 0;
		}
	}
}
void dfs(int k)
{
     
	//若超出范围，递归结束
	if (k == m) {
     
		//判断最后一行是否全为0，是则满足情况
		for (int i = 0; i < n; i++)
		{
     
			if (test[k-1][i] == 1)return; //存在一个非0，不满足
		}
		flag = 1;	//表示存在解决方案
		//满足判断是否最优
		int s = getCount();
		if (s < res) {
     
			res = s;
			copyArr(ans, save);
		}
		return;
	}
	//否则根据上一行设置本行
	for (int i = 0; i < n; i++)
	{
     
		turnOver(k, i, test[k - 1][i]);
	}
	//处理下一行
	dfs(k + 1);
}
void init()
{
     
	for (int k = 0; k < 1<<n; k++)//枚举第一行的2^n种情况
	{
     
		copyArr(test, orig);
		setZero(save);	//初始化每个位置翻转0次
		for (int i = 0; i < n; i++)	//根据枚举得到的k翻转第一行
		{
     
			int t;
			//依次取出二进制中的每一位，判断是1还是0
			//if ((k & 0x1 << (n-1-i)) == 0)t = 0;	//字典序从左到右还是从右到左都能ac
			if ((k & 0x1 << i) == 0)t = 0; //注意优先级
			else t = 1;
			turnOver(0, i, t);
		}
		dfs(1);	//根据第一行递归翻转下一行
	}
	
}

int main()
{
     
	while (~scanf("%d%d", &m, &n))
	{
     
		for (int i = 0; i < m; i++)
		{
     
			for (int j = 0; j < n; j++)
			{
     
				scanf("%d", &orig[i][j]);
			}
		}
		init();
		if (flag == 1) {
     
			for (int i = 0; i < m; i++)
			{
     
				for (int j = 0; j < n; j++)
				{
     
					if (j)printf(" ");
					printf("%d", ans[i][j]);
				}
				printf("\n");
			}
		}
		else printf("IMPOSSIBLE\n");
	}
	return 0;
}

附上测试数据：
7 8
0 0 0 0 1 0 1 0
0 0 0 0 0 0 1 0
1 0 0 0 1 0 0 1
0 1 0 1 1 0 0 1
0 0 0 1 1 0 1 1
0 0 0 1 0 0 0 0
0 1 0 0 0 0 0 0
它的答案是：
1 1 1 0 1 1 0 0
0 1 0 0 1 0 0 0
0 0 0 1 0 0 1 0
1 1 1 1 1 1 1 0
0 0 1 1 0 1 1 0
1 0 1 0 0 1 0 0
1 0 0 1 1 0 0 0