c++ 珊格迷宫问题

#demo1
#include<iostream>
#include<ctime>
#include<cstdlib>
#include<queue>
#include<cstdio>
using namespace std;
//生成迷宫
const int HEIGHT = ;
const int WIDTH = ;
bool isFound = false;
int maze[HEIGHT][WIDTH];
void initialMaze()
{

    maze[][] = ;//入口
    maze[HEIGHT - ][WIDTH - ] = ;//出口
    for (int i = ; i < HEIGHT; i++)//用随机数0,1填充迷宫
    {
        for (int j = ; j < WIDTH; j++)
        {
            if (i ==  && j == )
                continue;
            if (i == HEIGHT -  && j == WIDTH - )
                continue;
            maze[i][j] = rand() % ;
        }
    }

    //展示生成的迷宫
    for (int i = ; i < HEIGHT; i++)
    {
        for (int j = ; j < WIDTH; j++)
        {
            cout << maze[i][j];
            if (j != WIDTH - )
            {
                cout << " ";
            }
            else
            {
                cout << endl;
            }
        }
    }
}
//生成方向
int directory[][] = { {,},{,},{,},{,-},{,-},{-,-},{-,},{-,} };
//判断是否越界
bool isLeap(int x, int y)
{
    return x >=  && x < WIDTH&&y >=  && y < HEIGHT;

}
//任意位置的结构体
struct point {
    int x;
    int y;
};
//声明用于存储路径的结构体
struct dir
{
    int x;
    int y;
    int d;
};
//声明用于存储路径的队列
queue<dir> directoryQueue;
//迷宫循迹
dir path[HEIGHT][WIDTH];//记录迷宫的路径
int output[HEIGHT*WIDTH][];
void mazeTravel(point start, point end, int maze[HEIGHT][WIDTH], int directory[][])
{
    dir element;
    //dir tmp;
    int i;
    int j;
    int d;
    int a;
    int b;
    element.x = start.x;
    element.y = start.y;
    element.d = -;
    maze[start.x][start.y] = ;
    directoryQueue.push(element);
    while (!directoryQueue.empty())
    {
        element = directoryQueue.front();
        dir m = element;
        directoryQueue.pop();
        i = element.x;
        j = element.y;
        d = element.d + ;

        while (d < )
        {
            a = i + directory[d][];
            b = j + directory[d][];
            if (a == end.x&&b == end.y&&maze[a][b] == )
            {
                //储存前一个点的信息至path
                dir temp = m;
                temp.d = d;
                path[a][b] = temp;

                isFound = true;
                return;
            }
            if (isLeap(a, b)&&maze[a][b]==)
            {
                //储存前一个点的信息至path
                dir temp = m;
                temp.d = d;
                path[a][b] = temp;

                maze[a][b] = ;
                element.x = a;
                element.y = b;
                element.d = -;
                directoryQueue.push(element);
            }
            d++;
        }
    }
}
void printPath(point start, point end)
{
    if (!isFound)
        printf("The path is not found");
    else
    {
        int step = ;
        dir q;
        q.x = end.x;
        q.y = end.y;
        q.d = ;
        while (q.x != start.x || q.y != start.y)
        {
            output[step][] = q.x;
            output[step][] = q.y;
            output[step][] = q.d;
            int x = q.x;
            int y = q.y;
            q.x = path[q.x][q.y].x;
            q.y = path[x][q.y].y;
            q.d = path[x][y].d;
            step++;
        }
        output[step][] = q.x;
        output[step][] = q.y;
        output[step][] = q.d;
        printf("The path is as follows: \n");
        for (int i = step; i >= ; i--)
        {
            printf("(%d,%d)", output[i][], output[i][]);
            if (i != )
                printf("->");
        }
        printf("\n");
    }
}
int main()
{
    srand(time());
    initialMaze();
    point a, b;
    a.x = ;
    a.y = ;
    b.x = HEIGHT - ;
    b.y = WIDTH - ;
    mazeTravel(a, b, maze, directory);
    printPath(a, b);
    return ;
}

输出

The path is as follows:
(,)->(,)->(,)->(,)->(,)->(,)->(,)->(,)->(,)->(,)->(,)
Program ended with exit code: 

demo2

#demo2
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
using std::vector;
struct point
{
    int x;
    int y;
    int step;
    point(int _x, int _y, int _step) :x(_x), y(_y), step(_step) {}
    point(int _x, int _y) :x(_x), y(_y), step(){}
    point(){}
    bool operator==(const point& other)const
    {
        return x == other.x&&y == other.y;
    }
};
int minSteps_BFS(const vector<vector<int>>& path, vector<vector<point>>& mp, point src, point des, int step);
int main()
{
    vector<vector<int>> path = { { , , , ,  }, { , , , ,  }, { , , , ,  }, { , , , ,  }, { , , , ,  } };
    vector<vector<point>> mp(, vector<point>());
    point src(,);
    point des(,);
    int step = ;
    cout << minSteps_BFS(path, mp, src, des, step) << endl;
    cout << "具体路径如下：" << endl;
    //vector<point> res;
    while (!(mp[des.x][des.y] == src))
    {
        cout << des.x << " " << des.y << endl;
        des = mp[des.x][des.y];
    }
    cout << des.x << " " << des.y << endl;
    return ;
}

int minSteps_BFS(const vector<vector<int>>& path, vector<vector<point>>& mp, point src, point des, int step)
{
    const unsigned long n = path.size();
    const unsigned long m = path[].size();
    const int dx[] = { , , -,  };
    const int dy[] = { , -, ,  };
    vector<vector<bool>> flag(n, vector<bool>(m, false));
    flag[src.x][src.y] = true;
    queue<point> que;
    que.push(src);
    while (!que.empty())
    {
        point p = que.front();
        for (int i = ; i < ; ++i)
        {
            if (p.x + dx[i] <  || p.x + dx[i] >= n || p.y + dy[i] <  || p.y + dy[i] >= m)
                continue;
            if (path[p.x + dx[i]][p.y + dy[i]] ==  && !flag[p.x + dx[i]][p.y + dy[i]])
            {
                flag[p.x + dx[i]][p.y + dy[i]] = true;
                que.push(point(p.x + dx[i], p.y + dy[i], p.step + ));
                mp[p.x + dx[i]][p.y + dy[i]]= p;
                if (point(p.x + dx[i], p.y + dy[i], p.step + ) == des)
                {
                    return p.step + ;
                }
            }
        }
        que.pop();
    }
    return -;
}

输出

具体路径如下：

Program ended with exit code: 

参考：
https://www.cnblogs.com/xiugeng/p/9687354.html
https://blog.csdn.net/weixin_41106545/article/details/83211418