POJ 1753 - 位运算(异或)+BFS / DFS+枚举

1.Question:

题目大意:
有一个4*4的棋盘，棋盘上有黑白子，我们对棋盘进行如下操作：
操作的定义：我们每次可以反转一个棋子，即黑变白，白变黑，之后上下左右四个方向的棋子都会跟着进行翻转操作
题目中让我们求可以使得整个棋盘变成纯色的最少的操作次数

2.Solution1:

本题的解法思路有很多，之后的枚举+DFS的思路我会更新补上，这里我们着重讲解位运算+BFS的思路求解

首先，我们都很清楚，BFS对于求解最优解的搜索问题是一种很高效的查找解的方式，但是我们又清楚的意识到
BFS的算法本质在于维护一个动态的 队列以及一个记录数组（非必须，看题意），队列保存的是，每一次搜索完之后的状态，但是通过题意描述我们会发现期盼这种二维状态真的不好描述

所以说，本题就引入了一种处理的思路，因为棋盘限定为4*4（为了降低难度）我们将棋盘这样考虑

# # # #    //0 1 2 3
# # # #    //4 5 6 7
# # # #    //8 9 10 11
# # # #    //12 13 14 15
我们将每一个棋盘的格子是做一个二进制位的话，整个棋盘的所有的操作位数是16位，也就是说，最多会有2^16=65536种棋盘状态
那么我们将其用位运算压缩存储，一个int(或者unsigned short)就可以表示出一种状态

很显然，对于本题，我们还要尽量避免会出现重复搜索，v比如如果我们搜索到了之前的一个状态就要立即终止更换搜索的方式（防止无限循环）
刚好这种位压缩的思路对于我们记录来说也是很方便的
毕竟65536的存储单元内存消耗也不大

最后一个要点就是异或操作(^)，本题中因为我们是要反转，我是用1记录黑棋，0记录白棋，那么这样的话对于我们的异或操作也是很方便的，其实我们的翻转操作就是一个异或操作
1和任何数的异或是取反，0很任何数的异或操作是不变

最后要注意一个坑，对于一开始就是纯色的棋盘不要搜索，直接输出0

3.Code:

附上AC代码

#include"iostream"
#include"cstdio"
#include"cstring"
#include"cstdlib"
#define N 70000

using namespace std;

//黑1白0

typedef struct node
{
int data;
int step;
}kkk;

char map[4][4];
int judge
;
kkk queue
;
int head;
int tail;

int bit_trans(int atom,int data)
{
int mask=0;
mask|=(1<<atom);
if(atom%4!=0) mask|=(1<<(atom-1));   //左边
if(atom%4!=3) mask|=(1<<(atom+1));   //右边
if(atom>=4) mask|=(1<<(atom-4));    //上边
if(atom<=11) mask|=(1<<(atom+4));   //下边

return data^mask;
}

int bfs()
{
bool flag=0;   //是否成功
int s=0;
while(head!=tail)
{
for(int i=0;i<16;i++)
{
int dmove=bit_trans(i,queue[head].data);
if(dmove==0||dmove==65535)
{
s=queue[head].step+1;
flag=true;
break;
}
else if(judge[dmove]==1) continue;
else
{
judge[dmove]=1;
queue[tail].data=dmove;
queue[tail].step=queue[head].step+1;
tail++;
}
}
if(flag==true) break;
head++;
}
if(flag==1) return s;
else return -1;
}

int main()
{
memset(queue,0,sizeof(queue));
head=1;
tail=2;
for(int i=0;i<4;i++)
{
for(int j=0;j<4;j++) scanf("%c",&map[i][j]);
getchar();
}

for(int i=0;i<4;i++)
{
for(int j=0;j<4;j++)
{
if(map[i][j]=='b')
{
queue[head].data|=(1<<(4*j+i));
}
}
}

if(queue[head].data==0||queue[head].data==65535) printf("0\n");
else
{
int number=bfs();
if(number==-1) printf("Impossible\n");
else printf("%d\n",number);
}
return 0;
}

4.Solution2:

对于整个棋盘
我们的操作次数只有1，2，3，4.....16
我们每次只用摘出一个子序列，对于子序列中的元素进行反转操作
从小到大枚举可以保证我们找到最优解
核心在于抽取子序列：
为了方便描述，我用Python写了一下代码，思路很清晰，用了有序的DFS生产子序列排列，实际上，DFS不仅可以用来生成所有的子序列，DFS还可以生成全排列，详情搜索我额的全排列的代码

Python:

global count    #全局变量声明的时候不能初始化
count=0
global Exp

def initdata():
global Exp
list=[]   #数据域
data=eval(input("键入数据(列表)"))
Exp=eval(input("请输入抽取的元素的个数"))
grasp(data,list,0,0)
print("抽取的种类的个数%d"%count)

def print_tuple(list):
print(list)

def grasp(data,list,Now,index):   #index代表最末索引
global count    #哪里需要全局变量哪里声明一次
global Exp
if Now==Exp :
count+=1
print_tuple(list)
return
else:
for var in data[index:]:
list.append(var)
grasp(data,list,Now+1,index+1)
list.remove(var)
index=index+1

initdata()

5.Code:

#include"iostream"
#include"cstdio"
#include"cstring"
#include"cstdlib"

using namespace std;

char map[4][4];
int pre;
bool flag=false;
int count[16];
int number;
bool back=false;

int trans()
{
int k=pre;
int mask=0;
int dx;
for(int i=0;i<number;i++)
{
mask=0;
mask|=(1<<count[i]);
dx=count[i];
if(dx%4!=0) mask|=(1<<(count[i]-1));
if(dx%4!=3) mask|=(1<<(count[i]+1));
if(dx>=4) mask|=(1<<(count[i]-4));
if(dx<=11) mask|=(1<<(count[i]+4));
k=k^mask;
}
return k;
}

void grasp(int exp,int now,int index)
{
if(now==exp)
{
int w=trans();
if(w==0||w==65535) flag=1;
if(flag==1) return ;
else return ;
}
else
{
for(int i=index;i<16;i++)
{
count[number++]=i;
grasp(exp,now+1,index+1);
if(flag==1) return ;
index++;
number--;
}
}
}

void move(int step)
{
memset(count,0,sizeof(count));
number=0;
grasp(step,0,0);
}

int main()
{
pre=0;
for(int i=0;i<4;i++)
{
for(int j=0;j<4;j++)
{
scanf("%c",&map[i][j]);
if(map[i][j]=='b') pre|=(1<<(i*4+j));
}
getchar();
}
if(pre==0||pre==65535) printf("0\n");
else
{
int i;
for(i=1;i<=16;i++)
{
move(i);
if(flag==1) break;
}
if(flag==1) printf("%d",i);
else printf("Impossible\n");
}
return 0;
}