这个题目花了我很长时间，主要是用在考虑到底哪种方法合适。我只学会了其中关于组合的方法和用bfs加位运算的方法，至于0ms的方法，至今未明白。
下文是我粘到的两种方法
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，所以翻转的操作可以通过异或操作来完成，而翻转的位置可以通过移位来确定。
Cpp代码
- /*
- 简单分析：根据输入要求，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代码如下：
POJ 2965-The Pilots Brothers' refrigerator 提示：这题和POJ1753翻转棋的思想是一致的，需要注意的是要求输出翻转过程，因此不能用BFS，必须用DFS（找到目标后，还要过程回溯）Cpp代码
- #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;
- }
与POJ1753相比，这题还要注意翻棋的方法，若不注意会大大浪费时间导致超时，因为是整行整列翻转，在边界处会出现很多多余操作。代码中详细说明。
Cpp代码
- /*
- 先看一个简单的问题,如何把'+'变成'-'而不改变其他位置上的状态?答案是将该位置(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
第二种方法Cpp代码
- /*
- 代码二：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;
- }
主要思路如下：
1.对于每个格子，它要么反转0次，要么反转1次(当然，它的邻格子也跟着反转)，因为它反转偶数次和反转0次的效果是一样的，同理反转奇数次的效果和反转1次的效果是一样的。
2.由于只有16个格子，我们可以选择0个格子，1个格子，2个格子，3个格子......进行反转，总的选择情况为
3.当0个格子被反转时，看它是否为纯色，否则选择一个格子进行反转(有16种选择)，看反转后是否为纯色，否则选择两个格子进行反转(有120种选择)，看反转后是否为纯色......
4.只要"3过程"中有纯色出现，就停止"3过程"，输出相应的被选择的格子个数，结束。如果16个格子都被翻转了，还是没变成纯色，则输出“Impossible”。http://www.189works.com/article-58020-1.html /* 2 POJ 1753 Flip Game (递归枚举) 3 By Microgoogle 4 */ #include <stdio.h> #include <stdlib.h> //所有都是白的，或者所有都是黑的 int all_white_or_black(int* bits, int len) { int i = 0; for (i = 0; i < len - 1; i++) if (bits[i] != bits[i + 1]) return 0; return 1; } //改变一个格子的颜色，并根据其所在位置改变其周围格子的颜色 void change_color(int* arr, int i) { arr[i] = !(arr[i]); int x = i/4; int y = i%4; if (y < 3) arr[i + 1] = !(arr[i + 1]); if (y > 0) arr[i - 1] = !(arr[i - 1]); if (x > 0) arr[i - 4] = !(arr[i - 4]); if (x < 3) arr[i + 4] = !(arr[i + 4]); } //递归判断 //这个完全用了前一篇文章的递归方法，只是在else语句中添加了整个图形是否为纯色的判断而已 void combine(int* arr, int len, int* result, int count, const int NUM, int* last) { int i; for (i = len; i >= count; i--) { result[count - 1] = i - 1; if (count > 1) combine(arr, i - 1, result, count - 1, NUM, last); else { int j = 0; //在这里生成arr的副本 int* new_arr = (int*)malloc(sizeof(int)*16); for (j = 0; j < 16; j++) new_arr[j] = arr[j]; for (j = NUM - 1; j >=0; j--) { change_color(new_arr, result[j]); } if (all_white_or_black(new_arr, 16)) { *last = NUM; free(new_arr); break; } free(new_arr); } } } int main() { char str[5]; int bits[16]; int count = 15; int lines = 4; while (lines--) { scanf("%s", str); int i; for (i = 0; i < 4; i++) { if (str[i] == 'b') bits[count--] = 1; else bits[count--] = 0; } } //end while if (all_white_or_black(bits, 16)) printf("%d\n", 0); else { //生成bits数组的副本 int* new_bits = (int*)malloc(sizeof(int)*16); int i; for (i = 0; i < 16; i++) new_bits[i] = bits[i]; int j; //这里last用来接受combine函数里面的NUM，即需要的步数 int last = 0; for (j = 1; j <= 16; j++) { int* result = (int*)malloc(sizeof(int)*j); combine(new_bits, 16, result, j, j, &last); if (last == j) { printf("%d\n", last); break; } //new_bits已被改变，所以要还原为bits for (i = 0; i < 16; i++) new_bits[i] = bits[i]; free(result); } free(new_bits); if (j == 17) printf("Impossible\n"); } return 0; }
对于从16个格子中选取n个格子的所有组合，请看前一篇文章从数组中取出n个元素的所有组合（递归实现），这里不再叙述。
2364
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
