当前位置：首页 > news >正文

洛谷题目： P1225 黑白棋游戏题解（本题难）

news 来源：原创 2025/5/10 15:01:53

题目传送门：

P1225 黑白棋游戏 - 洛谷 (luogu.com.cn)

前言：

这道题要求我们找出从黑白棋游戏的初始棋盘状态变化到目标棋盘状态的最短着棋序列，也就是要找到最少的交换相邻方格棋子的步数以及每一步具体的交换位置。我们可以使用广度优先搜索（BFS）算法来解决这个问题，难度不大，以下是作者整理的本题整体思路：

题目整体思路（总结）：

广度优先搜索是一种适合用于寻找最短路径的算法，因为它会逐层扩展节点，一旦找到目标节点，所经过的路径必然是最短的。在本题中，每个棋盘状态可以看作图中的一个节点，相邻状态之间存在一条边。我们从初始状态开始，逐层扩展可能的状态，直到找到目标状态。

#具体实现步骤：

1、状态表示：

为了方便存储和比较棋盘状态，我们需要将二维的棋盘状态转换为一维的字符串。例如，对于一个 4x4 的棋盘，我们可以将其按行展开成一个长度为 16 的字符串，其中每个字符代表一个方格的棋子颜色。

2、数据结构设计：

Steate结构体：

用于存储当前的棋盘状态以及到达该状态所经过的移动序列。移动序列用

vector<pair<pair<int, int>, pair<int, int>>> 表示，其中每个 pair<pair<int, int>, pair<int, int>> 代表依次交换操作，包含着两个相邻方格的坐标。

队列 que<State>：

用于广搜，存储待扩展的状态。

哈希集合 unordered_set<string> ：

用于记录已经访问过的状态，避免重复搜索。

3、相邻方格判断：

编写一个函数 isadjacent 来判断两个方格是否相邻。在二维平面中，两个方格相邻以为着它们的曼哈顿距离为1，即横坐标差的绝对值加上纵坐标差的绝对值等于1.

4、棋子交换操作：

编写一个函数 swapieces 来实现交换两个相邻方格棋子的操作。该函数接受当前期盼状态和两个方格的坐标作为参数返回交换后的新棋盘状态。

##广度优先搜索过程：

1、初始化：

将初始状态加入队列，并将标记为已访问。

2、扩展状态：

从队列中取出一个状态，对于该状态下的每一个方格，检查其相邻方格。如果相邻方格合法，则交换这两个方格的棋子，得到一个新的状态。

3、判断新状态：

将新状态转换为字符串，如果该字符串不在已访问集合中，则将新状态加入队列，并更新移动序列和已访问集合。

4、终止条件：

当取出的状态与目标状态相同时，搜索结束，返回对应的移动序列。

5、输出结果：

输出移动序列的长度（即着棋步数），并依次输出每一步的交换信息，格式为 abcd，表示将棋盘上 (a, b) 处的棋子与 (c, d) 处的棋子换位。

###复杂度分析：

1、时间复杂度：

由于棋盘共有 16 个方格，每个方格有 2 种可能的颜色（白或黑），所以总的状态数为 $2^{16}$ 。在最坏情况下，我们需要遍历所有可能的状态，因此时间复杂度为 $O(2^{16})$ .

2、空间复杂度：

主要用于存储队列和已访问状态集合，空间复杂度同样为 $O(2^{16})$

####代码：

#include <bits/stdc++.h>
using namespace std;

struct S {
    string board;
    vector<pair<pair<int, int>, pair<int, int>>> moves;
};
string bs(const vector<vector<int>>& board) {
    string r;
    for (int i = 0; i < 4; ++i) {
        for (int j = 0; j < 4; ++j) {
            r += to_string(board[i][j]);
        }
    }
    return r;
}
bool A(int x1, int y1, int x2, int y2) {
    return (abs(x1 - x2) + abs(y1 - y2) == 1);
}
vector<vector<int>> spieces(const vector<vector<int>>& board, int x1, int y1, int x2, int y2) {
    vector<vector<int>> nb = board;
    swap(nb[x1][y1], nb[x2][y2]);
    return nb;
}
vector<pair<pair<int, int>, pair<int, int>>> bfs(const vector<vector<int>>& start, const vector<vector<int>>& target) {
    string targetStr = bs(target);
    queue<S> q;
    unordered_set<string> v;
    S initial;
    initial.board = bs(start);
    q.push(initial);
    v.insert(initial.board);
    while (!q.empty()) {
        S current = q.front();
        q.pop();
        if (current.board == targetStr) {
            return current.moves;
        }
        vector<vector<int>> cb(4, vector<int>(4));
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                cb[i][j] = current.board[i * 4 + j] - '0';
            }
        }
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                for (int dx = -1; dx <= 1; ++dx) {
                    for (int dy = -1; dy <= 1; ++dy) {
                        if ((dx == 0 && dy == 0) || (abs(dx) + abs(dy) != 1)) continue;
                        int ni = i + dx;
                        int nj = j + dy;
                        if (ni >= 0 && ni < 4 && nj >= 0 && nj < 4) {
                            vector<vector<int>> nb = spieces(cb, i, j, ni, nj);
                            string ns = bs(nb);
                            if (v.find(ns) == v.end()) {
                                S next;
                                next.board = ns;
                                next.moves = current.moves;
                                next.moves.emplace_back(make_pair(i + 1, j + 1), make_pair(ni + 1, nj + 1));
                                q.push(next);
                                v.insert(ns);
                            }
                        }
                    }
                }
            }
        }
    }
    return {};
}

int main()
{
    vector<vector<int>> start(4, vector<int>(4));
    vector<vector<int>> target(4, vector<int>(4));
    for (int i = 0; i < 4; ++i) {
        string line;
        cin >> line;
        for (int j = 0; j < 4; ++j) {
            start[i][j] = line[j] - '0';
        }
    }
    for (int i = 0; i < 4; ++i) {
        string line;
        cin >> line;
        for (int j = 0; j < 4; ++j) {
            target[i][j] = line[j] - '0';
        }
    }
    vector<pair<pair<int, int>, pair<int, int>>> moves = bfs(start, target);
    cout << moves.size() << endl;
    for (const auto& move : moves) {
        cout << move.first.first << move.first.second << move.second.first << move.second.second << endl;
    }
    
    
    
    
    return 0;
}