转载请注明出处：優YoU http://user.qzone.qq.com/289065406/blog/1299076400
提示：翻转棋，可以建模为多叉树
本题难点有两个，一个就是不要以全黑（或全白）作为目标进行搜索，而是要把全黑（或全白）作为“根”，去搜索树叶，看看是否有 输入的棋盘状态。
提示：其实每格棋子最多只可以翻转一次（实际是奇数次，但这没意义），只要其中一格重复翻了2次(不论是连续翻动还是不连翻动)，那么它以及周边的棋子和没翻动时的状态是一致的，由此就可以确定这个棋盘最多只能走16步，最多只能有翻出2^16种状态
本题有两种思路：
一种是常规思路，枚举所有状态，直至找到目标状态，而且由于只需要输出该种状态所在树的深度，因此推荐BFS，比较快，但DFS也可以的。详细方法见代码1
另外一种思路比较有技巧性，由于是4*4棋盘，因此利用了十六进制数的位数，通过一系列位运算达到目标，详细方法见代码2
1 /*代码一：DFS+Enum*/
2
3 //本题只要求输出翻转的次数，因此BFS或DFS都适用
4
5
6 //Memory Time
7 //240K 344MS
8
9
10 #include<iostream>
11 using namespace std;
12
13 bool chess[6][6]={false};//利用的只有中心的4x4
14 bool flag;
15 int step;
16 int r[]={-1,1,0,0,0};//便于翻棋操作
17 int c[]={0,0,-1,1,0};
18
19 bool judge_all(void)//判断“清一色”
20 {
21 int i,j;
22 for(i=1;i<5;i++)
23 for(j=1;j<5;j++)
24 if(chess[i][j]!=chess[1][1])
25 return false;
26 return true;
27 }
28
29 void flip(int row,int col)//翻棋
30 {
31 int i;
32 for(i=0;i<5;i++)
33 chess[row+r[i]][col+c[i]]=!chess[row+r[i]][col+c[i]];
34 return;
35 }
36
37 void dfs(int row,int col,int deep) //深搜的迭代回溯是重点，很容易混乱
38 {
39 if(deep==step)
40 {
41 flag=judge_all();
42 return;
43 }
44
45 if(flag||row==5)return;
46
47 flip(row,col); //翻棋
48 if(col<4)
49 dfs(row,col+1,deep+1);
50 else
51 dfs(row+1,1,deep+1);
52
53 flip(row,col); //不符合则翻回来
54 if(col<4)
55 dfs(row,col+1,deep);
56 else
57 dfs(row+1,1,deep);
58
59 return;
60 }
61
62 int main(void)
63 {
64 char temp;
65 int i,j;
66 for(i=1;i<5;i++)
67 for(j=1;j<5;j++)
68 {
69 cin>>temp;
70 if(temp=='b')
71 chess[i][j]=true;
72 }
73
74 for(step=0;step<=16;step++) //对每一步产生的可能性进行枚举
75 { //至于为什么是16，考虑到4x4=16格，而每一格只有黑白两种情况，则全部的可能性为2^16
76 dfs(1,1,0);
77 if(flag)break;
78 }
79
80 if(flag)
81 cout<<step<<endl;
82 else
83 cout<<"Impossible"<<endl;
84 return 0;
85 }
==============华丽的分割线================
1 /*代码二：BFS+Bit*/
2
3
4 //把矩阵看成一个16进制数
5 //每一行代表16进制数的一个字母（或数字），而每一个字母（或数字）又恰由4个二进制位数字0和1组成
6 //因此一个4x4矩阵是由16位0和1构成，是从 第0位 到 第15位
7 //如矩阵
8
9 // * * * * 从右到左分别为第 0, 1, 2, 3位
10 // % % % % 从右到左分别为第 4, 5, 6, 7位
11 // # # # # 从右到左分别为第 8, 9,10,11位
12 // @ @ @ @ 从右到左分别为第12,13,14,15位
13
14 //代表16进制数
15
16 // @@@@ #### %%%% ****
17 // 15 ← 0
18
19 // 将一个int的某位 取反 用该int与(0x1<<i)进行^操作。
20
21
22
23 #include<iostream>
24
25 struct unit
26 {
27 int x; //用int的末16位记录16个位置的信息
28 int rounds; //记录第几轮达到当前的状态
29 int i; //记录该状态是通过翻动哪个棋子得来的，以避免返回先前的状态
30 };
31
32
33 //flip函数是从a状态通过翻动第i个棋子到达b状态
34
35 void flip(unit a, int i, unit& b) //a是queue[p]的形参, 当前要翻动第i只棋子, b是queue[q]的引用
36 {
37 int x = i / 4, y = i % 4; //x、y为当前要翻动的第i只棋子所对应内节点的坐标（就是所翻动棋子的行x列y）
38 b.x = a.x; //即令queue[q].x=queue[p].x ,即q先复制p（前一步）的状态，再对q进行翻转（对p状态无影响）
39 b.x = ((b.x) ^ (0x1 << (i))); //将一个b.x的第i位 取反，其实就是把 第i只棋子 翻转
40 if (x > 0)
41 b.x = ((b.x) ^ (0x1 << (i - 4))); //把 第i只棋子 上面的棋子翻转，当且仅当棋子i不在第0行时执行
42 if (x < 3)
43 b.x = ((b.x) ^ (0x1 << (i + 4))); //把 第i只棋子 下面的棋子翻转，当且仅当棋子i不在第3行时执行
44 if (y > 0)
45 b.x = ((b.x) ^ (0x1 << (i - 1))); //把 第i只棋子 右面的棋子翻转，当且仅当棋子i不在第0列时执行
46 if (y < 3)
47 b.x = ((b.x) ^ (0x1 << (i + 1))); //把 第i只棋子 左面的棋子翻转，当且仅当棋子i不在第3列时执行
48 b.rounds = a.rounds + 1; //当前执行翻转棋子的次数
49 b.i = i; //记录当前翻转的是第i只棋子
50 return;
51 }
52
53 int main()
54 {
55 /*queue*/
56 unit queue[100000]; //queue是一个队列，记录所有状态
57 queue[0].x = 0; //初始化为16进制的0（16进制的0和10进制的0是一样的）
58 queue[0].i = -1;
59 queue[0].rounds = 0;
60
61 //judge used
62 bool used[100000]={false}; //used记录已经存在的状态
63 /*read in*/
64 char str[10];
65 for (int i = 0; i < 4; i++)
66 {
67 scanf("%s", str); //一次输入一行字符串str（串长为4），输4次
68 for (int j = 0; j < 4; j++)
69 if (str[j] == 'b')
70 queue[0].x = ((0x1 << (i * 4 + j)) | (queue[0].x)); //位运算，遇b该位置1
71 } // 0x1为16进制的1
72
73 int p = 0, q = 0; //p，q分别是队列的头尾指针
74
75 //其实queue[p].x代表每一步的翻转前状态，queue[q].x代表每一步的翻转后状态
76
77 while (!((queue[q].x == 0) || (queue[q].x == 0xFFFF))) //当16进制数queue[q].x 不为0（全0）或15（全1）时执行
78 {
79 for (int i = 0; i < 16; i++) //最多翻动16只棋子，i代表第i只棋子
80 {
81 if(queue[p].i==i) //若翻动当前棋子i的前一步所翻的棋子queue[p].i就是i，则跳过不翻动
82 continue;
83 q++; //尾指针后移一位，为新状态“开辟”新的记录空间
84 flip(queue[p], i, queue[q]);
85 if (used[queue[q].x]) //以棋盘的状态（一个16进制数）作为数组used的下标，对应的对象为true时说明这个状态已经出现过
86 q--; //在得到一个新状态的时候要检验之前时候存在这个状态，如果存在就把这个状态舍弃，即q--
87 //但是下一次循环则继续翻下一只棋子，与状态的舍弃无关，相当于本次所翻的棋子操作无效
88 else
89 used[queue[q].x]=true; //若该状态没有出现过，则记录该状态
90 if ((queue[q].x == 0) || (queue[q].x == 0xFFFF))break; //棋盘状态为全0或全1时跳出for，由于while的条件关系，自然也跳出while
91 }
92
93 if (p==q) //此条件为真时，当且仅当BFS到最后一层的最后一种状态时仍没有匹配的状态（全0或全1）
94 { //简单来说，就是当搜索到最后一层时，程序通过条件结束for,而不是通过break
95 printf("Impossible"); //直至搜索结束，队列queue中都没有目标状态（此时为impossible）。
96 break;
97 }
98
99 p++; //头指针后移一位，把当前状态作为初始状态
100 }
101 if ((queue[q].x == 0) || (queue[q].x == 0xFFFF)) //这是为了隔离因"impossible"时跳出while的情况
102 printf("%d\n", queue[q].rounds);
103 return 0;
104 }