POJ1753 棋盘翻转(位压缩+广度优先搜索)

原创 2012年03月25日 15:46:03

http://poj.org/problem?id=1753

题目大意:有一个4*4的方格,每个方格中放一粒棋子,这个棋子一面是白色,一面是黑色。游戏规则为每次任选16颗中的一颗,把选中的这颗以及它四周的棋子一并反过来,当所有的棋子都是同一个颜色朝上时,游戏就完成了。现在给定一个初始状态,要求输出能够完成游戏所需翻转的最小次数,如果初始状态已经达到要求输出0。如果不可能完成游戏,输出Impossible。

主要思想:

1、如果用一个4*4的数组存储每一种状态,不但存储空间很大,而且在穷举状态时也不方便记录。因为每一颗棋子都只有两种状态,所以可以用二进制0和1表示每一个棋子的状态,则棋盘的状态就可以用一个16位的整数唯一标识。而翻转的操作也可以通过通过位操作来完成。显然当棋盘状态id为0(全白)或65535(全黑)时,游戏结束。

2、对于棋盘的每一个状态,都有十六种操作,首先要判断这十六种操作之后是否有完成的情况,如果没有,则再对这十六种操作的结果分别再进行上述操作,显然这里就要用到队列来存储了。而且在翻转的过程中有可能会回到之前的某种状态,而这种重复的状态是不应该再次入队的,所以维护 Visit[i]数组来判断 id==i 的状态之前是否已经出现过,如果不是才将其入队。如果游戏无法完成,状态必定会形成循环,由于重复状态不会再次入队,所以最后的队列一定会是空队列。

3、由于0^1=1,1^1=0,所以翻转的操作可以通过异或操作来完成,而翻转的位置可以通过移位来确定。

/*
简单分析:根据输入要求,b代表黑棋(black),w代表白棋(white)。因为总共才16个位置,且只有黑白两种表示,此时,可对每一次状态进行二进制压缩(其中b代表1,w代表0),例如:
bwwb 
bbwb 
bwwb 
bwww
即可表示为1001 1101 1001 1000,其十进制值为40344。同时,计算可知根据黑白棋的摆放情况,总共有2^16种不同的状态。每一次经过有效的操作后,状态都会发生改变,此时,可借助二进制位运运算实现状态的改变,即对原有状态(相应的十进制表示)进行异或操作,以此来改变其对应二进制数的相关位置的值(1变0,0变1)。
例如:
先假设前一个状态为:
wwww 
wwww 
wwww 
wwww
即二进制表示为0000 0000 0000 0000,十进制对应为0。若此时选定左上角第一个棋子进行操作,根据规则,它右边和下边的也要同时进行变换(因为其左边和上边为空,不做考虑),之后,相应的状态用二进制表示,应变为:1100 1000 0000 0000,十进制值为51200。这个过程相当于对十进制数51200进行对十进制数0的异或操作,即next=0^(51200),而51200这个数则可以根据对十进制数1进行相应的左移操作得到。同时,我们知道,棋牌总共有16个位置,也就是说相应的不同的操作也有16种,即有16个不同的数经过异或操作用来改变前一个状态的值。那么,就先将这16个数枚出来吧,代码如下:
*/
int dir[4][2]={{1,0},{-1,0},{0,1},{0,-1}};
void init()
{
	int i,j,x,y,t,temp;
	for(i=0;i<4;++i)
	{
		for(j=0;j<4;++j)
		{
			temp = 0;
			temp ^= (1<<((3-i)*4+3-j));   //第一行代表16位的高4位,同理第一列也代表高位,所以棋盘(i,j)处在16位中的位置是((3-i)*4+3-j)
			//temp ^= (1<<(15 - ( i*4 + j )));
			for(t=0;t<4;++t)
			{
				x = i + dir[t][0];
				y = j + dir[t][1];
				if(x<0 || y<0 || x>3 || y>3)
					continue;
				temp ^= (1<<((3-x)*4+3-y));
			}
			cout<<temp<<" ";
		}
		cout<<endl;
	}
}

完整的AC代码如下:

#include<iostream>
#include<queue>
#include<cstdio>
using namespace std;
#include<memory.h>

struct Node
{
	int state;
	int step;
};

bool visit[65536];

int change[16] =   //16种状态转换,对应4*4的翻子位置
{
	 51200,58368,29184,12544,
     35968,20032,10016,4880,
	 2248,1252,626,305,
	 140,78,39,19
};

int bfs(int state)
{
	int i;
	memset(visit,false,sizeof(visit));    //标记每一个状态都未访问过
	queue<Node>q;
	Node cur,next;
	cur.state = state;
	cur.step = 0;
	q.push(cur);
	visit[state] = true;

	while(!q.empty())
	{
		cur = q.front();
		q.pop();
		if(cur.state == 0 || cur.state == 0xffff)   //65535
			return cur.step;
		for(i=0;i<16;i++)
		{
			next.state = cur.state^change[i];
			next.step = cur.step + 1;
			if(visit[next.state])
				continue;
			if(next.state == 0 || next.state == 0xffff)   //65535
				return next.step;
			visit[next.state] = true;
			q.push(next);
		}
	}
	return -1;
}

int main(void)
{
	int i,j,state,ans;
	char ch[5][5];
	while(scanf("%s",ch[0])!=EOF)
	{
		for(i = 1 ; i < 4 ; ++i)
			scanf("%s",ch[i]);
		state = 0;
		for(i = 0 ; i < 4 ; ++i)
		{
			for(j = 0 ; j < 4 ; ++j)
			{
				state <<= 1;
				if(ch[i][j] == 'b')
					state += 1;
				//state ^= (1<<((3-i)*4+(3-j)));
			}
		}
		ans = bfs(state);
		if(ans == -1)
			puts("Impossible");
		else
			printf("%d\n",ans);
	}
	return 0;
}
POJ  2965-The Pilots Brothers' refrigerator
提示:这题和POJ1753翻转棋的思想是一致的,需要注意的是要求输出翻转过程,因此不能用BFS,必须用DFS(找到目标后,还要过程回溯)

与POJ1753相比,这题还要注意翻棋的方法,若不注意会大大浪费时间导致超时,因为是整行整列翻转,在边界处会出现很多多余操作。代码中详细说明

/*
先看一个简单的问题,如何把'+'变成'-'而不改变其他位置上的状态?答案是将该位置(i,j)及位置所在的行(i)和列(j)上所有的handle更新一次,
结果该位置被更新了7次,相应行(i)和列(j)的handle被更新了6次,剩下的被更新了4次.
被更新偶数次的handle不会造成最终状态的改变.因此得出高效解法,在每次输入碰到'+'的时候,
自增该位置与相应的行和列,当输入结束后,遍历数组,所有为奇数的位置则是操作的位置,
而奇数位置的个数之和则是最终的操作次数.
*/
#include<iostream>
#include<cstdio>
using namespace std;

 int main(void)
 {
	 int i,j,k,result;
	 bool ch[4][4] = {false};
	 char handle;
	 for(i = 0; i < 4; ++i)
	 {
		 for(j = 0; j < 4; ++j)
		 {
			 scanf("%c",&handle);
			 if(handle == '+')
			 {
				 ch[i][j] = !ch[i][j];
				 for(k = 0; k < 4; ++k)
				 {
					 ch[i][k] = !ch[i][k];
					 ch[k][j] = !ch[k][j];
				 }
			 }
		 }
		 getchar();
	 }
	 result = 0;
	 for(i = 0; i < 4; ++i)
	 {
		 for(j = 0; j < 4; ++j)
		 {
			 if(ch[i][j])
			 {
				 ++result;
			 }
		 }
	 }
	 printf("%d\n",result);
	 for(i = 0; i < 4; ++i)
	 {
		 for(j = 0; j < 4; ++j)
		 {
			 if(ch[i][j])
				 printf("%d %d\n",i+1,j+1);
		 }
	 }
	 return 0;
 }

方法二: DFS+Bit

/*
代码二:DFS+Bit
本题由于要输出每次翻转的棋子,因此不适宜用BFS,应该使用DFS输出完整路径
*/
 #include<iostream>
 #include<cstdio>
 using namespace std;
 
 int chess;        //棋盘状态
 int step;
 bool flag=false;
 int ri[16],cj[16];
 
 bool isopen(void)
 {
     if(chess == 0xFFFF)
         return true;
     else
         return false;
 }
 
 void flip(int bit)
 {
     chess=chess^(0x1<<bit);  //对翻转位取反
     int row=bit/4;
     int col=bit%4;
     for(int c=0;c<4;c++)
         chess=chess^(0x1<<(row*4+c));  //对全行取反
     for(int r=0;r<4;r++)
         chess=chess^(0x1<<(r*4+col));  //对全列取反
     return;
 }
 
 void dfs(int bit,int deep)
 {
     if(deep==step)
     {
         flag=isopen();
         return;
     }
 
     if(flag || bit>15)
		 return;
 
     int row=ri[deep]=bit/4;
     int col=cj[deep]=bit%4;
 
     flip(bit);
     if(col<4)
         dfs(bit+1,deep+1);
     else
         dfs((bit+4)/4*4,deep+1);
 
     flip(bit);
     if(col<4)
         dfs(bit+1,deep);
     else
         dfs((bit+4)/4*4,deep);
     return;
 }
 
 int main(void)
 {
     char temp;
     int i,j;
     for(i=0;i<4;i++)
	 {
         for(j=0;j<4;j++)
         {
             cin>>temp;
             if(temp=='-')
                 chess=chess^(1<<(i*4+j));
         }
	 }
 
     /*DFS*/
     for(step=0;step<=16;step++)
     {
         dfs(0,0);
         if(flag)
             break;
     }
 
	 printf("%d\n",step);
     for(i=0;i<step;i++)
		 printf("%d %d\n",ri[i]+1,cj[i]+1);
     return 0;
 }




 

相关文章推荐

POJ 1753 Flip Game (DFS 太暴力了!)

Flip Game Description Flip game is played on a rectangular 4x4 field with two-sided pieces pla...

poj 1753 Flip Game(枚举,bfs)(简单)

poj 1753 Flip Game题目http://poj.org/problem?id=1753 给你一个4*4的棋盘,每个棋子非黑即白,翻一个棋子会带动它上下左右的棋子也翻过来,问至少多少...

poj_1753 递归+枚举

思路是别人的,自己理解了半天,渣渣
  • yeruby
  • yeruby
  • 2014年04月08日 20:48
  • 1505

POJ1753 棋盘翻转(位压缩+广度优先搜索)

Flip Game   Description Flip game is played on a rectangular 4x4 field with two-s...

POJ1753-Flip Game

转载请注明出处:優YoU  http://user.qzone.qq.com/289065406/blog/1299076400提示:翻转棋,可以建模为多叉树本题难点有两个,一个就是不要以全黑(或全白...

POJ1753 Flip Game DFS+枚举

题目大意:有一个4×4的棋盘,棋盘上每一点都有黑白两面,每次可以翻转任意一点,在翻转某一点时,该点上下左右的4个临近点同时也会被翻转,现在问你要使棋盘上所有点的颜色统一所需要的最小翻转次数。 分析:...

POJ1753 Flip Game

这是一个贪心题。 我用的是八皇后的算法。 代码操作也差不多。 下面是代码: #include int a[17],b,w,min,cut; void up(int i) { if(i-4>=...

POJ 1753 翻棋子 (dfs+递归)。

终于来填坑了。依旧是递归的题目,最近做的都是关于递归的问题。下一个是汉诺塔问题。 这道题也是看了很多别人的博客才弄出来的,但是分析还是要试着自己写一下。 题意是这样的,有一个4*4的棋盘,你可以自...

POJ1753 状态压缩(+BFS) + 棋盘问题

0 棋盘问题,改变一个子的颜色,这个子以及这个子周围的四个位置(左右上下)的子分别变色,求最少的改变次数。 此类题大部分应该可以用状态压缩+暴力搜索解决。纯粹找规律不太合理。   1)第一种方法,状态...

POJ1753 flip Game翻转棋盘

/*题目大意:有一个4*4的方格,每个方格中放一粒棋子,这个棋子一面是白色,一面是黑色。 游戏规则为每次任选16颗中的一颗,把选中的这颗以及它四周的棋子一并反过来,当所有的棋子都是同一个颜色朝上时,...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:POJ1753 棋盘翻转(位压缩+广度优先搜索)
举报原因:
原因补充:

(最多只允许输入30个字)