POJ1753-Flip Game

转出处：優YoU  http://user.qzone.qq.com/289065406/blog/1299076400

提示：翻转棋，可以建模为多叉树

本题难点有两个，一个就是不要以全黑（或全白）作为目标进行搜索，而是要把全黑（或全白）作为“根”，去搜索树叶，看看是否有 输入的棋盘状态。

 另一个难点需要一点数学功底，就是要知道 树 的最大高度，这是“状态不存在”的判断标准

提示：其实每格棋子最多只可以翻转一次（实际是奇数次，但这没意义），只要其中一格重复翻了2次(不论是连续翻动还是不连翻动)，那么它以及周边的棋子和没翻动时的状态是一致的，由此就可以确定这个棋盘最多只能走16步，最多只能有翻出2^16种状态

 

 

本题有两种思路：

一种是常规思路，枚举所有状态，直至找到目标状态，而且由于只需要输出该种状态所在树的深度，因此推荐BFS，比较快，但DFS也可以的。详细方法见代码1

另外一种思路比较有技巧性，由于是4*4棋盘，因此利用了十六进制数的位数，通过一系列位运算达到目标，详细方法见代码2

 

[cpp]  view plain copy

1. /*代码一：DFS+Enum*/  
2.   
3. //Memory Time   
4. //240K   344MS   
5.   
6. //本题只要求输出翻转的次数，因此BFS或DFS都适用  
7.   
8. #include<iostream>  
9. using namespace std;  
10.   
11. bool chess[6][6]={false};//利用的只有中心的4x4  
12. bool flag;  
13. int step;  
14. int r[]={-1,1,0,0,0};//便于翻棋操作  
15. int c[]={0,0,-1,1,0};  
16.   
17. bool judge_all(void)//判断“清一色”  
18. {  
19.     int i,j;  
20.     for(i=1;i<5;i++)  
21.         for(j=1;j<5;j++)  
22.             if(chess[i][j]!=chess[1][1])  
23.                 return false;  
24.     return true;  
25. }  
26.   
27. void flip(int row,int col)//翻棋  
28. {  
29.     int i;  
30.     for(i=0;i<5;i++)  
31.         chess[row+r[i]][col+c[i]]=!chess[row+r[i]][col+c[i]];  
32.     return;  
33. }  
34.   
35. void dfs(int row,int col,int deep) //深搜的迭代回溯是重点，很容易混乱  
36. {  
37.     if(deep==step)  
38.     {  
39.         flag=judge_all();  
40.         return;  
41.     }  
42.   
43.     if(flag||row==5)return;  
44.   
45.     flip(row,col);       //翻棋  
46.     if(col<4)  
47.         dfs(row,col+1,deep+1);  
48.     else  
49.         dfs(row+1,1,deep+1);  
50.   
51.     flip(row,col);      //不符合则翻回来  
52.     if(col<4)  
53.         dfs(row,col+1,deep);  
54.     else  
55.         dfs(row+1,1,deep);  
56.   
57.     return;  
58. }  
59.   
60. int main(void)  
61. {  
62.     char temp;  
63.     int i,j;  
64.     for(i=1;i<5;i++)  
65.         for(j=1;j<5;j++)  
66.         {  
67.             cin>>temp;  
68.             if(temp=='b')   
69.                 chess[i][j]=true;  
70.         }  
71.   
72.     for(step=0;step<=16;step++)  //对每一步产生的可能性进行枚举  
73.     {                            //至于为什么是16，考虑到4x4=16格，而每一格只有黑白两种情况，则全部的可能性为2^16  
74.         dfs(1,1,0);  
75.         if(flag)break;  
76.     }  
77.   
78.     if(flag)  
79.         cout<<step<<endl;  
80.     else  
81.         cout<<"Impossible"<<endl;  
82.     return 0;  
83. }  

 

==============华丽的分割线================

 

[cpp]  view plain copy

1. /*代码二：BFS+Bit*/  
2.   
3. //把矩阵看成一个16进制数  
4. //每一行代表16进制数的一个字母（或数字），而每一个字母（或数字）又恰由4个二进制位数字0和1组成  
5. //因此一个4x4矩阵是由16位0和1构成，是从 第0位 到 第15位  
6. //如矩阵    
7.   
8. //        * * * *      从右到左分别为第 0, 1, 2, 3位  
9. //        % % % %      从右到左分别为第 4, 5, 6, 7位  
10. //        # # # #      从右到左分别为第 8, 9,10,11位  
11. //        @ @ @ @      从右到左分别为第12,13,14,15位  
12.   
13. //代表16进制数    
14.   
15. //   @@@@ #### %%%% ****  
16. //  15      ←         0  
17.   
18. //   将一个int的某位 取反 用该int与(0x1<<i)进行^操作。  
19.     
20.   
21.   
22. #include<iostream>   
23.   
24. struct unit  
25. {   
26.     int x;   //用int的末16位记录16个位置的信息  
27.     int rounds;   //记录第几轮达到当前的状态  
28.     int i;   //记录该状态是通过翻动哪个棋子得来的，以避免返回先前的状态  
29. };   
30.   
31.   
32. //flip函数是从a状态通过翻动第i个棋子到达b状态  
33.   
34. void flip(unit a, int i, unit& b)   //a是queue[p]的形参, 当前要翻动第i只棋子, b是queue[q]的引用  
35. {   
36.     int x = i / 4, y = i % 4;   //x、y为当前要翻动的第i只棋子所对应内节点的坐标（就是所翻动棋子的行x列y）  
37.     b.x = a.x;      //即令queue[q].x=queue[p].x  ,即q先复制p（前一步）的状态，再对q进行翻转（对p状态无影响）  
38.     b.x = ((b.x) ^ (0x1 << (i)));    //将一个b.x的第i位 取反，其实就是把 第i只棋子 翻转  
39.     if (x > 0)   
40.         b.x = ((b.x) ^ (0x1 << (i - 4)));  //把 第i只棋子 上面的棋子翻转，当且仅当棋子i不在第0行时执行  
41.     if (x < 3)   
42.         b.x = ((b.x) ^ (0x1 << (i + 4)));  //把 第i只棋子 下面的棋子翻转，当且仅当棋子i不在第3行时执行  
43.     if (y > 0)   
44.         b.x = ((b.x) ^ (0x1 << (i - 1)));  //把 第i只棋子 右面的棋子翻转，当且仅当棋子i不在第0列时执行  
45.     if (y < 3)   
46.         b.x = ((b.x) ^ (0x1 << (i + 1)));  //把 第i只棋子 左面的棋子翻转，当且仅当棋子i不在第3列时执行  
47.     b.rounds = a.rounds + 1;   //当前执行翻转棋子的次数  
48.     b.i = i; //记录当前翻转的是第i只棋子  
49.     return;  
50. }   
51.   
52. int main()   
53. {   
54.     /*queue*/   
55.     unit queue[100000];     //queue是一个队列，记录所有状态  
56.     queue[0].x = 0;   //初始化为16进制的0（16进制的0和10进制的0是一样的）  
57.     queue[0].i = -1;   
58.     queue[0].rounds = 0;   
59.       
60.     //judge used   
61.     bool used[100000]={false};    //used记录已经存在的状态  
62.     /*read in*/   
63.     char str[10];   
64.     for (int i = 0; i < 4; i++)   
65.     {   
66.         scanf("%s", str);  //一次输入一行字符串str（串长为4），输4次  
67.         for (int j = 0; j < 4; j++)  
68.             if (str[j] == 'b')    
69.                 queue[0].x = ((0x1 << (i * 4 + j)) | (queue[0].x));  //位运算，遇b该位置1  
70.     }                     // 0x1为16进制的1  
71.   
72.     int p = 0, q = 0;     //p，q分别是队列的头尾指针  
73.   
74.     //其实queue[p].x代表每一步的翻转前状态，queue[q].x代表每一步的翻转后状态  
75.   
76.     while (!((queue[q].x == 0) || (queue[q].x == 0xFFFF)))      //当16进制数queue[q].x 不为0（全0）或15（全1）时执行  
77.     {   
78.         for (int i = 0; i < 16; i++)   //最多翻动16只棋子，i代表第i只棋子  
79.         {   
80.             if(queue[p].i==i)   //若翻动当前棋子i的前一步所翻的棋子queue[p].i就是i，则跳过不翻动  
81.                 continue;   
82.             q++;   //尾指针后移一位，为新状态“开辟”新的记录空间  
83.             flip(queue[p], i, queue[q]);   
84.             if (used[queue[q].x])  //以棋盘的状态（一个16进制数）作为数组used的下标，对应的对象为true时说明这个状态已经出现过  
85.                 q--;               //在得到一个新状态的时候要检验之前时候存在这个状态，如果存在就把这个状态舍弃，即q--    
86.                                     //但是下一次循环则继续翻下一只棋子，与状态的舍弃无关，相当于本次所翻的棋子操作无效  
87.             else  
88.                 used[queue[q].x]=true; //若该状态没有出现过，则记录该状态  
89.             if ((queue[q].x == 0) || (queue[q].x == 0xFFFF))break; //棋盘状态为全0或全1时跳出for，由于while的条件关系，自然也跳出while  
90.         }   
91.   
92.         if (p==q) //此条件为真时，当且仅当BFS到最后一层的最后一种状态时仍没有匹配的状态（全0或全1）  
93.         {         //简单来说，就是当搜索到最后一层时，程序通过条件结束for,而不是通过break  
94.             printf("Impossible");    //直至搜索结束，队列queue中都没有目标状态（此时为impossible）。   
95.             break;   
96.         }   
97.   
98.         p++; //头指针后移一位，把当前状态作为初始状态  
99.     }   
100.     if ((queue[q].x == 0) || (queue[q].x == 0xFFFF))   //这是为了隔离因"impossible"时跳出while的情况  
101.         printf("%d\n", queue[q].rounds);   
102.     return 0;   
103. }