C++处理迷宫问题（创建，dfs寻路，bfs寻路）

已于 2023-07-19 12:25:19 修改
阅读量437 收藏 4
点赞数 3
文章标签： c++ 数据结构 课程设计
于 2023-07-15 10:34:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beijieyu/article/details/131736053
版权 
#include<iostream>
#include<algorithm>
#include<cstring>
#include<math.h>
#include<stdio.h>
#include<stdlib.h>
#include<Windows.h>
#include<conio.h>
#include<graphics.h>
#include <random>
#include <functional>
#define MaxSize 10010
#define side 101

using namespace std;
typedef struct
{
    int x, y, la;
}position;
typedef struct {
    position data[MaxSize];
    int front, rear;
}Queue;
char maze[side][side] = {};
char maze1[side][side] = {};
int dy[4] = { 1,0,-1,0 };
int dx[4] = { 0,1,0,-1 };
bool fi[side][side] = { };
int m, n;
int way_proportion = 70;
bool find_ = true;
void create_Maze();//创建迷宫
void  print_maze();//输出迷宫
void reduction_maze();//还原迷宫/赋值副本
void initialize_maze();//初始化墙
void  initQueue(Queue& que);
void enQueue(Queue& q, position d);
void deQueue(Queue& q);
void dfs_find_way(int x, int y);
void bfs_find_way();
void getsize();//获取m,n
void create_maze_dfs(int x,int y);
void dfs_create(int row, int col);
void  mgpath(int xi, int yi, int xe, int ye);

struct Node {
    int x; // 当前节点的 x 坐标
    int y; // 当前节点的 y 坐标
    int dir; // 下一个坐标方向
    Node* next; // 指向下一个节点的指针
};

class LinkedStack {
private:
    Node* top; // 栈顶节点指针

public:
    LinkedStack() {
        top = nullptr;
    }

    bool isEmpty() {
        return top == nullptr;
    }

    void push(int x, int y, int dir) {
        Node* newNode = new Node;
        newNode->x = x;
        newNode->y = y;
        newNode->dir = dir;
        newNode->next = top;
        top = newNode;
    }

    void pop() {
        if (isEmpty()) {
            return;
        }
        Node* temp = top;
        top = top->next;
        delete temp;
    }

    Node* getTop() {
        return top;
    }
};
//寻路8
void mgpath(int startX, int startY, int endX, int endY) {
   
    LinkedStack stack;
    stack.push(startX, startY, 0);
    maze1[startX][startY] =maze1[endX][endY]= ' ';
    bool foundPath = false;

    while (!stack.isEmpty()) {
        Node* top = stack.getTop();
        int x = top->x;
        int y = top->y;
        int dir = top->dir;
        // 到达终点
        if (x == endX && y == endY) {
            // 打印路径
            maze1[1][1] = 'S';
            maze1[m - 2][n - 2] = 'E';
            print_maze();
            cout << "路径: ";
            while (!stack.isEmpty()) {
                Node* node = stack.getTop();
                cout << "(" << node->x << "," << node->y << ") ";
                stack.pop();
            }
            cout << endl;
            foundPath = true;
            break;
        }
        bool found = false;
        // 尝试四个方向的移动：右、下、左、上
        for (int i = dir; i < 4; i++) {
            if (i == 0 && y + 1 < n && maze1[x][y + 1] == ' ') {
                stack.push(x, y + 1, 0); // 向右走
                maze1[x][y + 1] = '@';
                found = true;
                break;
            }
            else if (i == 1 && x + 1 < m && maze1[x + 1][y] == ' ') {
                stack.push(x + 1, y, 0); // 向下走
                maze1[x + 1][y] = '@';
                found = true;
                break;
            }
            else if (i == 2 && y - 1 >= 0 && maze1[x][y - 1] == ' ') {
                stack.push(x, y - 1, 0); // 向左走
                maze1[x][y - 1] = '@';
                found = true;
                break;
            }
            else if (i == 3 && x - 1 >= 0 && maze1[x - 1][y] == ' ') {
                stack.push(x - 1, y, 0); // 向上走
                maze1[x - 1][y] = '@';
                found = true;
                break;
            }
        }
        if (!found) {
            // 如果四个方向都不能移动，回溯
            stack.pop();
            maze1[x][y] = 'V';
        }
        else {
            // 更新下一个坐标方向
            top->dir = dir + 1;
        }
        HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
        // 设置控制台窗口缓冲区大小
        COORD bufferSize = { 120, 120 };
        SetConsoleScreenBufferSize(hOut, bufferSize);
        print_maze();
    }
    if (!foundPath) {
        // 没有找到路径
        cout << "没有找到路径" << endl;
    }
}
//改比例
void change_way_proportion()
{
    while (1)
    { cout << "请输入路径比例" << endl;
        cin >> way_proportion;
        if (way_proportion <= 0 || way_proportion > 99)
        {
            cout << "数值不规范" << endl;
            continue;
        }
        break;
    }
    create_Maze();
    print_maze();
    return;
}
//初始化
void initialize_maze()//初始化
{
    for (int i = 0;i < m;i++)
    {
        for (int j = 0;j < n;j++)
        {
            maze[i][j] = '#';
        }
    }
    maze[1][1] = 'S';
    maze[m - 2][n - 2] = 'E';
}//初始化迷宫
int IsHaveNeighbor(int X_index, int Y_index)//判断是否有邻居
{
        if ((X_index >= 3 && maze[X_index - 2][Y_index] == '#') || (X_index < m - 3 && maze[X_index + 2][Y_index] == '#') || (Y_index >= 3 && maze[X_index][Y_index - 2] == '#') || (Y_index < n - 3 && maze[X_index][Y_index + 2] == '#'))
            return 1;//有邻居
        return 0;      
}
void dfs_create(int X_index, int Y_index){
    int rand_position, x, y, flag = 0;
    x = X_index;
    y = Y_index;
    //如果四个方向都没有了，返回上一步的xy，否则，继续
    while (1)
    {
        flag = IsHaveNeighbor(X_index, Y_index);
        if (flag == 0)
        {
            return;//返回该函数的上一条
        }
        else
        {
            maze[X_index][Y_index] =' ';
            while (1)
            {
                rand_position = rand() % 4;
                if (rand_position == 0 && X_index >= 3 && maze[X_index - 2][Y_index] == '#')//上
                {
                    X_index = X_index - 2;
                }
                else if (rand_position == 1 && X_index < m- 3 && maze[X_index + 2][Y_index] == '#')//下
                {
                    X_index = X_index + 2;
                }
                else if (rand_position == 2 && Y_index >= 3 && maze[X_index][Y_index - 2] == '#')//左
                {
                    Y_index -= 2;
                }
                else if (rand_position == 3 && Y_index < n - 3 && maze[X_index][Y_index + 2] == '#')//右
                {
                    Y_index += 2;
                }
                maze[(x + X_index) / 2][(y + Y_index) / 2] =' ';//当前位置，移动后位置中间位置打通，表示路径
                maze[X_index][Y_index] = ' ';
                dfs_create(X_index, Y_index);
                break;
            }
        }
    }
}
void create_maze_dfs(int rows,int columns)
{
    initialize_maze();
    random_device rd;
    mt19937 generator(rd());

    int start_row = generator() % rows;
    int start_col = generator() % columns;

    dfs_create( start_row, start_col); // 调用DFS算法生成迷宫
    maze[1][2] = ' ';
    maze[2][1] = ' ';
    maze[m-2][n-3] = ' ';
    maze[m-3][n-2] = ' ';
    maze[1][1] = 'S';
    print_maze();
}
void deQueue(Queue& q)
{
    q.front++;
}
void enQueue(Queue& q, position d)
{
    q.data[q.rear] = d;
    q.rear++;
}
void  initQueue(Queue& que) {
    que.front = que.rear = 0;
}
void reduction_maze()
{
    for (int i = 1; i < m - 1; ++i) {
        for (int j = 1; j < n - 1; ++j)
        {
            maze1[i][j] = maze[i][j];
        }
    }
    print_maze();
}
void  print_maze()
{
    Sleep(20);
    system("cls");
    int i = 0, j = 0;
    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            if (maze1[i][j] == 'S'|| maze1[i][j] == 'E')
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_BLUE);
                cout << "█ ";
            }
            else if (maze1[i][j] == '#')
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED);
                cout << "█ ";
            }
            else if (maze1[i][j] == ' ')
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_GREEN);
                cout << "█ ";
            }
            else if (maze1[i][j] == 'V')
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN);
                cout << "█ ";
            }
            else if (maze1[i][j] == '@')
            {
                SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_BLUE);
                cout << "█ ";
            }
          // cout << maze1[i][j] << " ";
        }
        cout << endl;
    }
    cout<< "***********星树***************" << endl
        << "*  输入1重新随机生成迷宫     *" << endl
        << "*  输入2生成基于DFS迷宫      *" << endl
        << "*  输入3还原迷宫             *" << endl
        << "*  输入4深搜                 *" << endl
        << "*  输入5广搜                 *" << endl
        << "*  输入6修改迷宫大小         *" << endl
        << "*  输入7修改可行路径比例     *" << endl
        << "*  输入8非递归寻路           *" << endl
        << "*  输入q退出                 *" << endl
        << "******************************" << endl;
    //system("pause");
}
void create_Maze() {
    // 初始化迷宫为墙
    initialize_maze();
    // 随机生成路径
    srand(time(NULL));
    for (int i = 1; i < m - 1; i++) {
        for (int j = 1; j < n - 1; j++) {

            // 生成0~99之间的随机数
            int randomNumber = rand() % 100;
            if (randomNumber < way_proportion&& maze[i][j]=='#') {  // 50%的概率生成路径
                maze[i][j] = ' ';
            }
        }
    }
   
   
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j)
        {
            maze1[i][j] = maze[i][j];
        }
    }
}
void dfs_find_way(int x, int y)
{
    if (find_)
    {
        return;
    }
    else {
        for (int i = 0;i < 4;i++)
        {

            int nextx = x + dx[i], nexty = y + dy[i];
            if (maze1[nextx][nexty] == 'E')
            {
                find_ = true;
                return;
            }
            if (maze1[nextx][nexty] == ' ' && !fi[nextx][nexty] && !find_)
            {
                maze1[nextx][nexty] = '@';

                HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
                // 设置控制台窗口缓冲区大小
                COORD bufferSize = { 120, 120 };
                SetConsoleScreenBufferSize(hOut, bufferSize);

                print_maze();
                fi[nextx][nexty] = true;
                dfs_find_way(nextx, nexty);
                if (!find_)
                    maze1[nextx][nexty] = 'V';
            }

       }
    }
}
void bfs_find_way()
{
    reduction_maze();
    Queue que;
    position d;
    d.x = 1;
    d.y = 1;
    d.la = 0;
    initQueue(que);
    enQueue(que, d);
    while (que.front != que.rear)
    {
        auto fr = que.data[que.front];
        for (int i = 0;i < 4;i++)
        {
            d.x = fr.x + dx[i];
            d.y = fr.y + dy[i];
            if (maze1[d.x][d.y] == ' ')
            {
                d.la = que.front;
                enQueue(que, d);
                maze1[d.x][d.y] = 'V';
            }
            if (maze1[d.x][d.y] == 'E')
            {
                int  lt = que.front;
                while (que.data[lt].la != 0) {
                    maze1[que.data[lt].x][que.data[lt].y] = '@';
                    lt = que.data[lt].la;
                }

                maze1[que.data[lt].x][que.data[lt].y] = '@';

                HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
                // 设置控制台窗口缓冲区大小
                COORD bufferSize = { 120, 120 };
                SetConsoleScreenBufferSize(hOut, bufferSize);


                print_maze();
                cout << "已找到路径" << endl;
                return;
            }
        }
        HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
        // 设置控制台窗口缓冲区大小
        COORD bufferSize = { 120,120 };
        SetConsoleScreenBufferSize(hOut, bufferSize);
        print_maze();
        deQueue(que);
    }
    cout << "无路径" << endl;
    return;
}
void getsize()
{
    while (1)
    {
        cout << "请输入迷宫的长（5-100)：" << endl;
        cin >> m;
        cout << "请输入迷宫的宽（5-100)：" << endl;
        cin >> n;
        if (m <=4 || n <=4)
        {
            cout << "迷宫太小了";
            continue;
        }
        if (m >= 100 || n >= 100)
        {
            cout << "迷宫太大了";
            continue;
        }
        break;
    }
}
int main()
{ 
    while (1)
    {
        getsize();
        create_Maze();
        print_maze();
        while (true)
        {
            char c;
            cin >> c;
            switch (c)
            {
            case '1'://重新生成迷宫
                create_Maze();
                print_maze();
                break;
            case'2'://dsf生成     
                create_maze_dfs(m,n);
                reduction_maze();
                break;
            case'3'://还原迷宫
                reduction_maze();
                break;
            case'4'://dfs
                reduction_maze();
                find_ = false;
                memset(fi, false, sizeof(fi));
                dfs_find_way(1, 1);
                if (!find_)
                    cout << "无路径" << endl;
                else
                    cout << "已找到路径" << endl;
                break;
            case'5'://bfs
                bfs_find_way();
                break;
            case'6'://改尺寸
                getsize();
                create_Maze();
                print_maze();
                break;
            case'7'://改比例
                change_way_proportion();
                create_Maze();
                break;
            case'8':
                reduction_maze();
                mgpath(1,1,m - 2, n - 2);
                break;
            case'q'://退出
                return 0;
            default:
                string error_in;
                cin >> error_in;
                cout << "输入错误" << endl;
                break;
            }
        }
    }
}

‘#’为墙

‘@’为路径

‘S'E’分别为起点终点

‘V’为可到达的点

星夜下的琼瑶树
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
C++迷宫问题的求解算法
12-20
本文实例为大家分享了C++实现迷宫的具体代码，供大家参考，具体内容如下 一、 实验目的： （1） 熟练掌握链栈的基本操作及应用。 （2） 利用链表作为栈的存储结构，设计实现一个求解迷宫的非递归程序。 二、实验内容： 【问题描述】 以一个m×n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍。设计一个程序，对信任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 【基本要求】 首先实现一个链表作存储结构的栈类型，然后编写一个求解迷宫的非递归程序。求得的通路以三元组（i,j,d）的形式输出，其中：（i,j）指示迷宫中的一个坐标，d表示走到下一坐标的方向。如：对于下列数据的迷宫，输
c语言 -迷宫寻路
huangmingcsdn的博客
08-17 944
代码】c语言 -迷宫寻路。
c++深搜1-迷宫类问题
Mark1277的博客
06-11 3754
深搜-迷宫类问题
C++迷宫问题完全详解
最新发布
weixin_42163707的博客
12-20 2255
深度优先搜索（DFS）和广度优先搜索（BFS）是两种常用的图遍历算法，适用于不同的问题和场景。广度优先使用的是Queue队列，队列是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口。这里使用了栈，stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口。迷宫我们都玩过，有些复杂的看的眼花缭乱，但是有没有想过，让机器帮你完成这个工作，想着就很酷，好，在实际应用中，根据问题的特点和需求，选择合适的算法来进行图遍历是非常重要的。
C++迷宫问题
Christopherwa的博客
01-28 4580
C++迷宫问题
C++ 实现迷宫问题
ztt_1105的博客
07-21 2547
通过C++设计了一个迷宫游戏，涉及到链表，C++基本操作，终端字符处理，深度优先遍历算法。下面开始吧！ 在全局变量中定义地图，包括地图的长和高（30*20），同时还需定义一些标记。 flag 用于创建地图，true代表地图传创建成功。 slow用于更换游戏速度，true代表游戏慢速。 autogame用于更换游戏模式，true代表自动游戏。 #define MAX_X 20 #define...
C++-VS2019-迷宫寻路BFS+DFS代码.zip
07-22
最终效果是实现了Prim随机生成迷宫，BFS&DFS路径显示、最短路长度显示、过程动态展示，主函数中有菜单，操作方便。 不仅可以用来读代码长知识、还可以用作算法演示。 附带第五版的exe文件，欢迎使用！
迷宫寻路问题C++源码
08-31
在IT领域，迷宫寻路问题是一个经典...通过分析和运行这段代码，我们可以深入理解C++如何处理复杂的问题，并掌握DFS、BFS以及可能的A*算法的实现细节。对于计算机科学的学生和程序员来说，这是提升算法技能的重要实践。
迷宫寻路，从起点寻路到出口
11-17
本文将深入探讨迷宫寻路问题，包括其基本概念、常见算法以及如何使用C和C++编程语言进行实现。 首先，迷宫寻路问题可以抽象为一个二维网格或图，其中每个节点代表一个位置，而边则表示相邻的位置。迷宫的起点和终点...
迷宫自动寻路mfc
11-09
DFS和BFS在解决迷宫问题时都能找到路径，但BFS通常能找到最短路径，因为它按照距离目标节点的顺序进行搜索。A*算法则更高效，它结合了BFS的全局最优性和DFS的局部搜索效率，通过启发式函数预估每个节点到达目标的...
迷宫问题_C++
DYNA_M的博客
04-01 2049
Description 有一个 10 x 10 的迷宫，起点是‘S’，终点是‘E’，墙是‘#’，道路是空格。一个机器人从起点走到终点。当机器人走到一个通道块，前面已经没有路可走时，它会转向到当前面向的右手方向继续走。如果机器人能够过，则留下足迹‘*’，如果走不通，则留下标记‘!’。 下面给出书中的算法，请你模拟机器人的走法输出最终的状态。 Input 一个 10 x 10 的二维字符数组。 Out...
C++ || 数据结构--迷宫问题
weixin_63378697的博客
04-14 1151
迷宫为一个mⅹn的阵列，阵列中的值为0或1（具体数值随机生成），分别表示可以通行（简称“通”）和不可以通行（简称“不通”），左上角（即“(1,1)”）为入口，右下角为出口（即“(m,n)”），每个的出行方向有8个。要求：设计一个算法完成找一条从入口到出口的最短路径。
【C++】迷宫
None
05-16 3686
C++实现迷宫
数据结构——迷宫问题（顺序栈、C++）
m0_53468233的博客
08-01 9523
顺序栈求解随机生成迷宫的通路（C++)
使用C/C++解决迷宫问题
IT_jishuyuan的博客
11-06 2257
使用C/C++解决迷宫问题 一、设计步骤 1、绘制迷宫 int Mg[10][10]={ {1,1,1,1,1,1,1,1,1,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,1,0,0,0,1,0,1}, {1,0,0,0,0,1,1,0,0,1}, {1,0,1,1,1,0,0,0,0,1}, {1,0,0,0,1,0,0,0,0,1}, {1,0,1,0,0,0,1,0,0,1}, {1,0,1,1,1,0
迷宫c++(详解)
ASBSIHD的博客
03-19 1176
迷宫c++(详解)
【栈】实现迷宫求解(C++)(详解)
半生瓜のblog
10-15 6215
迷宫求解 从入口进入开始， 向不同方向试探，走到死胡同就退回。 找迷宫通路需要使用回溯法，找迷宫通路是对回溯法的一个很好的应用，实现回溯的过程用到数据结构—栈！ 回溯法： ​ 对一个包括有很多个结点，每个结点有若干个搜索分支的问题，把原问题分解为若干个子问题求解的 算法；当搜索到某个结点发现无法再继续搜索下去时，就让搜索过程回溯(回退)到该节点的前一个结点，继续 搜索该节点外的其他尚未搜索的分支；如果发现该结点无法再搜索下去，就让搜索过程回溯到这个结点的前一 结点继续这样的搜索过程；这样的搜索过程一
C++迷宫问题求解（用队列实现）
程序设计
09-02 1781
19、迷宫问题求解（用队列实现）【任务】以一个m*n的长方阵表示迷宫。0和1分别表示迷宫中的通路和障碍。解迷宫通常用的是“穷举求解”方法，即从入口出发、顺着某个方向进行探索、若能走通，则继续往前进;否则沿着原路退回，换一个方向继续探索，直至出口位置，求得一条通路。假如所有可能的通路都探索到而未能到达出口，则所设的迷宫没有通路。【数据结构】可以二维数组存储迷宫数据，为处理方便起见可在迷宫的四周加一圈障碍。对于迷宫中任一位置、均可约定有东、南、西、北四个方向可通。
迷宫求解C/C++
CampusAmour的博客
03-04 1508
迷宫求解：利用数据结构中的栈来求解迷宫路径。
pta 迷宫寻路c语言
06-10
好的，针对你的问题，我可以给出一些关于 PTA 迷宫寻路 C 语言的基本实现思路。 首先，我们需要将输入的迷宫转换成一个矩阵，用二维数组来存储。然后选择一种搜索算法，比如 DFS（深度优先搜索）或 BFS（广度优先搜索），来遍历迷宫中的每一个点，直到找到终点。 在搜索的过程中，我们需要记录每个点的状态，比如它是否已经被访问过、它的前驱节点是哪一个等等。这些状态可以通过一个结构体来表示。 最后，当我们找到终点时，我们可以通过回溯的方式，从终点开始，一直追溯到起点，将路径上的点保存下来，输出即可。 以上就是一个基本的 PTA 迷宫寻路 C 语言实现的思路，具体代码实现可以根据不同的算法和数据结构来进行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值