有一个8x8的棋盘，上面有4颗棋子，棋子可以上下左右移动。给定一个初始 状态很一个目标状态，问能否在8步以内到达---BFS

1 有一个8x8的棋盘，上面有4颗棋子，棋子可以上下左右移动。给定一个初始 状态很一个目标状态，问能否在8步以内到达

要解决这个问题，我们可以使用一种称为宽度优先搜索（BFS）的算法。这种算法可以帮助我们找到从初始状态到目标状态的最短路径。在这个场景中，每个状态可以表示为棋盘上的一种棋子布局，每次移动可以将一个棋子上下左右移动到空白位置，如果能在8步以内从初始状态转变为目标状态，则返回能够到达，否则返回不能到达。

由于棋盘大小固定为8x8，且棋子数量为4，我们可以通过将棋盘上的位置编码成一个唯一的状态来处理这个问题。例如，我们可以使用棋子在棋盘上的位置的序列来表示一个状态。

为了进行宽度优先搜索，我们需要做以下几步：

1. 将初始状态作为搜索的起点。
2. 对于当前状态，考虑所有可能的单步移动，生成一系列新的状态。
3. 检查这些新状态是否达到了目标状态。
4. 如果没有达到目标状态，且步数小于8，则将这些新状态加入待搜索队列。
5. 重复步骤2到4，直到找到目标状态或者搜索完所有可能的状态。

请提供初始状态和目标状态的具体描述，例如棋子的位置，这样我才能进行更具体的计算。

#include <iostream>
#include <queue>
#include <unordered_set>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

const int N = 8; // 棋盘大小

// 将棋子的位置编码为字符串，用于唯一表示一个状态
string encode(const vector<pair<int, int>>& pieces) {
   
    string code;
    for (const auto& p : pieces) {
   
        code += to_string(p.first * N + p.second) + ";";
    }
    return code;
}

// 宽度优先搜索，检查是否可以在8步内从初始状态到达目标状态
bool canReachInEightMoves(vector<pair<int, int>> start, vector<pair<int, int>> goal) {
   
    queue<pair<vector<pair<int, int>>, int>> q;
    unordered_set<string> visited;
    string goalState = encode(goal);

    q.push({
   start, 0});
    visited.insert(encode(start));

    while (!q.empty()) 
    {
   
        auto [pieces, steps] = q.front(); q.pop();

        if (encode(pieces) == goalState) return true;
        if (steps >= 8) continue;

        for (int i = 0; i < pieces.size(); ++i) {
   
            vector<pair<int, int>> dirs = {
   {
   0, 1}, {
   1, 0}, {
   0, -1}, {
   -1, 0}}; // 上，右，下，左
            for (const auto& [dx, dy] : dirs) {
   
                int nx = pieces[i].first + dx;
                int ny = pieces[i].second + dy;
                
                // 检查新位置是否有效：在棋盘内且不被其他棋子占据
                if (nx >= 0 && nx < N && ny >= 0 && ny < N) {
   
                    bool occupied = any_of(pieces.begin()