迷宫用队列搜索最优路径

         

！！注意！！：

           本章建立在上章的建立迷宫结构的基础上，本章只是在其基础上做出修改和查询最优路径的功能，上章链接为：https://blog.csdn.net/Lincooo/article/details/140193188?spm=1001.2014.3001.5501

一、问题描述： 

        迷宫只有两个门，一个门叫入口，另一个门叫出口。一个骑士骑马从入口走进迷宫，迷宫中设置很多墙壁，对前进方向形成了多处障碍。骑士需要在迷宫中寻找通路以到达出口。设计程序，基于广度优先算法求解从入口到出口之间的最短路径。

二、功能要求：

        （1）创建迷宫：根据用户输入的行数n(3<=n<=100)和列数m(3<=m<=100)，假定入口始终在（1，1）位置，出口始终在（n,m）位置，创建一个n*m个格子的迷宫，要求屏幕中能显示迷宫信息。

        （2）创建障碍：用户输入障碍数k（1<k<n*m）,在创建好的迷宫中，随机将k个格子设置为障碍，不能将入口和出口设置为障碍，要求能在迷宫中显示障碍信息。

        （3）走迷宫：从入口开始，在迷宫中寻找通路达到出口，障碍处无法通行。要求输出所经过的路线，如果无法达到出口，给出相应提示。其中，给定1张方格地图，1代表墙，0代表路。运动方向包括东南西北四个。输出最短路径值，以及从入口到出口的详细路径。

三、解决思路：

        1、建立结点类、边类、迷宫类。

        2、根据输入信息建立迷宫结构。

        3、使用bfs算法遍历图。

四、具体代码：

      1、迷宫类

        添加bfs函数的声明

class maze
{
public:
    unordered_map<int, Node *> nodes;
    unordered_set<Edge *> edges;
    maze(){};
    void creatMaze(int n, int m, int k, vector<vector<int>> &myMaze);
    maze creatGraph(vector<vector<int>> mitrix); // 建无向图
    void bfs(Node *start, int n, int m);//获取一条最短路径
    void print(vector<vector<int>> myMaze, maze graph, int n, int m);
};

      2、主函数

        添加bfs函数的调用

int main()
{
    int n, m, k;
    while (true)
    {
        cout << "please input the row and col" << endl;
        cin >> n >> m;
        cout << "please input the number of barriers" << endl;
        cin >> k;
        if (isValidInput(n, m, k))
        {
            break;
        }
    }
    vector<vector<int>> myMaze(n + 2, vector<int>(m + 2, 0));
    maze graphMaze;
    vector<Node *> path;
    graphMaze.creatMaze(n, m, k, myMaze);
    graphMaze = graphMaze.creatGraph(myMaze);
    cout << "The shortest path:" << endl;
    graphMaze.bfs(graphMaze.nodes[1], n, m); 
    return 0;
}

      3、搜素算法

void maze::bfs(Node *start, int n, int m)
{
    if (start == nullptr)
        return;

    queue<pair<Node *, vector<Node *>>> myQuene; // 队列中存储节点和对应的路径
    myQuene.push({start, {start}});              // 初始节点和初始路径
    int count = 0;
    while (!myQuene.empty())
    {
       pair<Node *, vector<Node *>> topElement = myQuene.front();
          Node *cur = topElement.first;
          vector<Node *> &path = topElement.second;
        myQuene.pop();
        // 深度优先搜索下一步可行的节点
        for (auto next : cur->nexts)
        {
            // 检查是否已经在路径径
            if (find(path.begin(), path.end(), next) == path.end())
            {
                vector<Node *> nextPath = path; // 创建新的路径
                nextPath.push_back(next);       // 将下一节点加入路径径
                myQuene.push({next, nextPath}); // 压入队列中
                                                // 如果当前节点是终点，输出路径
                if (next->value == n * m)
                {
                    cout << "value:";
                    for (auto node : nextPath)
                    {
                        cout << node->value << " ";
                    }
                    cout << endl;
                    cout << "xy:";
                    for (auto node : nextPath)
                    {
                        cout << "(" << node->row << "," << node->col << ")"
                             << " ";
                    }
                    cout << "    The length is " << path.size() << endl;
                    cout << endl;
                    count++;
                    return;
                }
            }
        }
    }
    if (count == 0)
    {
        cout << "No way" << endl;
    }
}