P1225 黑白棋游戏（双向BFS，二进制及位运算）

题目描述

黑白棋游戏的棋盘由4×4方格阵列构成。棋盘的每一方格中放有1枚棋子，共有8枚白棋子和8枚黑棋子。这16枚棋子的每一种放置方案都构成一个游戏状态。在棋盘上拥有1条公共边的2个方格称为相邻方格。一个方格最多可有4个相邻方格。在玩黑白棋游戏时，每一步可将任何2个相邻方格中棋子互换位置。对于给定的初始游戏状态和目标游戏状态，编程计算从初始游戏状态变化到目标游戏状态的最短着棋序列。

输入输出格式

输入格式：

 

输入文件共有8行。前四行是初始游戏状态，后四行是目标游戏状态。每行4个数分别表示该行放置的棋子颜色。“0”表示白棋；“1”表示黑棋。

 

输出格式：

 

输出文件的第一行是着棋步数n。接下来n行，每行4个数分别表示该步交换棋子的两个相邻方格的位置。例如，abcd表示将棋盘上(a，b)处的棋子与(c，d)处的棋子换位。

//注：本题可能有多种答案，但是目前洛谷special judge尚未开发完成，因此不保证正确的程序一定ac，结果仅供参考。

 

输入输出样例

输入样例#1： 复制

1111
0000
1110
0010
1010
0101
1010
0101

输出样例#1： 复制

4
1222
1424
3242
4344

说明

 

题解：将矩阵转化为二进制数

#include<cstdio>
#include<algorithm>
using namespace std;
int B[16]={1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768};
int P[16]={44,43,42,41,34,33,32,31,24,23,22,21,14,13,12,11}; //
int h[2][65536];//对应hash码，存的就是每一种状态
bool vis[2][65536];
int step[2][65536];
int fa[2][65536];//对应父节点
int pos[2][65536];//记录上一步变换得来的位置(始终是左上点)
bool dir[2][65536];//记录上一步是左右交换(0)还是上下交换(1)
int head[2],tail[2]={1,1};
int start,target,s,key;
void print0(int n)
{
    if(n==start)
    return;
    print0(fa[0][n]);
    int a=pos[0][n],b=pos[0][n]-1-3*dir[0][n];
    printf("%d%d\n",P[a],P[b]);          //用递归就从头开始输出
}
void print1(int n)
{
    if(n==target)
    return;
    int a=pos[1][n],b=pos[1][n]-1-3*dir[1][n];//要么下要么右·
    printf("%d%d\n",P[a],P[b]);
    print1(fa[1][n]);                   //用递归从尾开始输出
}
void record(int n)
{
    printf("%d\n",step[0][n]+step[1][n]);
    print0(n);    //因为是双向，所以
    print1(n);
}
void BFS(int x)    //双向BFS
{
    int k;
    head[x]++;
    int num=h[x][head[x]];
    int f,b,n;
    for (k=15;k>=0;k--)
    {
        if(k%4!=0)
        {
            f=num&B[k];                //左右交换 ,好长时间才反应过来，这是左右交换，不是左右移动
                                       //md左右交换当前位置为左
            b=num&B[k-1];              //所以要考虑两个点。f是换到右，b是换到左
            n=num-f+(f>>1)-b+(b<<1);   //真的很巧妙,减掉原来的，加上现在移动的
            if (vis[x][n]==0)
            {
                tail[x]++;
                h[x][tail[x]]=n;
                vis[x][n]=1;
                step[x][n]=step[x][num]+1; //计算步数
                fa[x][n]=num;              //记录前一步的状态，前一步状态自然就是从左到右，从上到下了。
                pos[x][n]=k;               //记录上一步的位置，一个k打位置表也是666了
                dir[x][n]=0;               //记录上一步是左右移动还是上下移动，0是左右移动，1是上下移动。
            }
        }
        if(vis[0][n]&&vis[1][n])          //因为广搜每次只进行一次上下与左右交换，所以当他们的点同时有了，那就一定是相遇点了
        {                                 //也就是说双向BFS是找相遇点，MD，这不是废话吗
            record(n);
            key=1;
            return;
        }
        if(k>=4)                          //上下交换
        {
            f=num&B[k];
            b=num&B[k-4];
            n=num-f+(f>>4)-b+(b<<4);    //交换当前位置为上
            if (vis[x][n]==0)
            {
                tail[x]++;
                h[x][tail[x]]=n;
                vis[x][n]=1;
                step[x][n]=step[x][num]+1;
                fa[x][n]=num;
                pos[x][n]=k;
                dir[x][n]=1;
            }
        }
        if (vis[0][n]&&vis[1][n])
        {
            record(n);
            key=1;
            return;
        }
    }
}
int main()
{
    int i;
    for(i=15;i>=0;i--)
    {
        scanf("%1d",&s);
        start+=s<<i;
    }
    for(i=15;i>=0;i--)
    {
        scanf("%1d",&s);
        target+=s<<i;
    }
    h[0][1]=start;
    h[1][1]=target;            //两个端点啊。
    vis[0][start]=1;
    vis[1][target]=1;          //表示这种状态已经存在。
    while(head[0]<tail[0]&&head[1]<tail[1])
    {
        BFS(0);
        if (key) break;
        BFS(1);
        if (key) break;
    }
    return 0;