题目: 黑白棋游戏

黑白棋游戏

题目描述

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

输入格式

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

输出格式

输出$n$，表示最少需要多少步才能到达目标状态。

样例 #1

样例输入 #1

1111
0000
1110
0010
1010
0101
1010
0101

样例输出 #1

4

提示

提示就是没有提示awa

题解

        这是一道非常直白的广度优先搜索问题，所以只要套模板即可，模板可以参考我之前的文章。

简单分析一下，每次有24种交换的可能，即每一行的 第一个 第二个 第二个 第三个和第三个 第四个交换，每一列的第一个 第二个 第二个 第三个和第三个 第四个交换。那么只要根据这个构建出一棵树就好啦。


废话不多说，上代码！

#include <iostream>
#include <cstdio>
#include <bitset>
#include <queue>
#include <cmath>

using namespace std;

char a[16], target[16]; // 数组
struct NODE {
    bitset<16>b;
    int step;
}now, nextt, temp;
queue<NODE>q;   // 队列

short F[65535] = { 0 };

bool check(NODE a)
{
    if (F[a.b.to_ulong()] == 0)
    {
        return true;
    }
    else if (F[a.b.to_ulong()] == 3)
    {
        return true;
    }
    else
    {
        return false;
    }
}

int main()
{
    for (int i = 0; i < 16; i++)
    {
        cin >> a[i];
    }
    for (int i = 0; i < 16; i++)
    {
        cin >> target[i];
    }
    bitset<16>hash_a(a);
    bitset<16>hash_target(target);

    // 设置终点
    F[hash_target.to_ulong()] = 3;

    // 起始点入队
    now.b = hash_a;
    now.step = 0;
    q.push(now);
    F[now.b.to_ulong()] = 1;

    while (!q.empty())
    {
        // 不断取出队首
        now = q.front();
        q.pop();

        temp = now;

        // 遍历同一层的24种可能

        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 3; j++)
            {
                now = temp;

                // 横向交换
                int t = now.b[4 * i + j];
                now.b[4 * i + j] = now.b[4 * i + j + 1];
                now.b[4 * i + j + 1] = t;

                // 走动
                if (check(now))
                {
                    // 构造下一个节点
                    nextt.step = now.step + 1;
                    nextt.b = now.b;

                    if (F[nextt.b.to_ulong()] == 3)   // 到达中点
                    {
                        cout << nextt.step << endl;
                        return 0;
                    }

                    // 入队
                    q.push(nextt);
                    F[nextt.b.to_ulong()] = 1;
                }
            }
        }

        for (int j = 0; j < 4; j++)
        {
            for (int i = 0; i < 3; i++)
            {
                now = temp;

                // 纵向交换
                int t = now.b[j + i * 4];
                now.b[j + i * 4] = now.b[j + (i + 1) * 4];
                now.b[j + (i + 1) * 4] = t;

                if (check(now))
                {
                    // 构造下一个节点
                    nextt.step = now.step + 1;
                    nextt.b = now.b;
                    
                    // 走动
                    if (F[nextt.b.to_ulong()] == 3)   // 到达中点
                    {
                        cout << nextt.step << endl;
                        return 0;
                    }

                    // 入队
                    q.push(nextt);
                    F[nextt.b.to_ulong()] = 1;
                }
            }
        }
    }
    


    return 0;
}

（其实这里的代码还可以再优化一下的QAQ，懒~）

结语

        这里有一个小小的问题，就是这段代码再我自己的电脑上跑（c++11标准）是完全没有问题的，但是上传到oj上就提示编译错误了，我也不知道为啥，能有大佬解释一下吗QAQ。如果实在不行可以自己写这个bitset部分，主要就只有将二进制转化位10进制的部分，用一个数组完全可以搞定，但是我…是吧，所有就…是吧（阅读理解部分awa）。


（溜啦溜啦~嘻→嘻↘嘻→嘻↗嘻↗嘻↗嘻↗）