栈和递归解决迷宫问题

最新推荐文章于 2021-03-04 21:01:48 发布
最新推荐文章于 2021-03-04 21:01:48 发布
阅读量572 收藏 2
点赞数 1
分类专栏： c++ 数据结构 文章标签： 栈 递归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hudazhe/article/details/78220056
版权

先给出一个迷宫的模型。0代表通路，1代表墙壁，知道出入口后，找到入口到出口之间的通路。
先给出一个简单迷宫模型
这里写图片描述
现在令下方为出口方向，[2,0]作为入口寻找通路。将走过的路程标记为2。
此时可以发现迷宫存在一个分叉口，假如以顺时针方向对是否存在通路进行判别，则必定会先走没有出口的那一条死路，而当走进死路时，需要进行回溯。
此时可以开辟一个栈用来维护这条通路，先将入口进行压栈，随后判别通路，将通路压栈，当走到死路的时候，进行一次出栈操作。当回溯到有其他通路时，则进行压栈，保存下一条通路了。
代码实现：
利用递归保证对每一条通路都会进行判别。

#pragma once
#include <iostream>
#include <stack>
#include <list>
#include <string>
using namespace std;

struct Pos    //定义一个坐标
{
    size_t _row;    //行
    size_t _col;    //列
};
//回溯
//利用栈来记录以及回溯 pop
#if 1
template <size_t M, size_t N>
class Maze
{
public:
    Maze(int maze[][N]);    //初始化一个迷宫
    void Print();   //打印迷宫
    bool CheckAccess(Pos next);  //判断该点是否合法
    bool GetPath(Pos entry);
protected:
    int _maze[M][N];
};
template <size_t M, size_t N>
Maze<M, N>::Maze(int maze[][N]) {   //初始化迷宫
    for (size_t i = 0; i < M; i++) {
        for (size_t j = 0; j < N; j++) {
            _maze[i][j] = maze[i][j];
        }
    }
}
template <size_t M, size_t N>
void Maze<M, N>::Print() {          //打印迷宫
    for (size_t i = 0; i < M; i++) {
        for (size_t j = 0; j < N; j++) {
            cout << _maze[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}
template <size_t M, size_t N>
bool Maze<M, N>::CheckAccess(Pos next) {   //判断该点是否合法
                                           //不溢出或者有通路返回真
    if (next._row < M&&next._col < N&&_maze[next._row][next._col] == 0)
        return true;
    return false;
}
template <size_t M, size_t N>
bool Maze<M, N>::GetPath(Pos entry) {    //找出口
    Pos cur;
    cur = entry;
    Pos next;

    stack<Pos>path;    //创建栈帧
    path.push(entry);  //将起点压栈
    while (!path.empty())   //当栈为空证明没有出口 跳出
    {
        cur = path.top();   //起始即为起点
        //每次都是栈顶的点
        _maze[cur._row][cur._col] = 2;
        if (cur._row == M - 1) {
            return true;
        }
        //顺时针排查
        next = cur;        //next指向当前位置
        next._row -= 1;    //上
        if (CheckAccess(next)) {   //检验上方是否有通路
            path.push(next);  //如果符合则压栈
            continue;
        }
        next = cur;        //next指向当前位置
        next._col += 1;    //右
        if (CheckAccess(next)) {   //检验右方是否有通路
            path.push(next);  //如果符合则压栈
            continue;
        }
        next = cur;        //next指向当前位置
        next._row += 1;    //下
        if (CheckAccess(next)) {   //检验下方是否有通路
            path.push(next);  //如果符合则压
            continue;
        }
        next = cur;        //next指向当前位置
        next._col -= 1;    //左
        if (CheckAccess(next)) {   //检验左方是否有通路
            path.push(next);  //如果符合则压
            continue;
        }
        path.pop();  //如果以上4个都不符合 证明走到死路  利用后进先出的特点进行回溯
    }
    return false;
}
void test() {
    int mazeA[10][10] = {
        { 1,1,1,1,1,1,1,1,1,1 },
        { 1,1,1,1,1,1,1,1,1,1 },
        { 0,0,0,1,1,1,1,1,1,1 },
        { 1,1,0,1,1,1,1,1,1,1 },
        { 1,1,0,1,1,1,1,1,1,1 },
        { 1,1,0,1,1,1,1,1,1,1 },
        { 1,1,0,0,0,1,1,1,1,1 },
        { 1,1,0,1,1,1,1,1,1,1 },
        { 1,1,0,1,1,1,1,1,1,1 },
        { 1,1,0,1,1,1,1,1,1,1 }
    };
    Maze<10, 10>maze(mazeA);
    maze.Print();
    Pos entry = { 2,0 };
    maze.GetPath(entry);
    maze.Print();
}

期待的运行方式：
这里写图片描述
运行结果：
这里写图片描述
与所期待的运行结果相同。
缺点：不能对有两条通路以上的迷宫求最优解，也不能对带环的迷宫进行求解。

解决求解有两条以上通路以及带环的迷宫的最短路；
对于带有两条以上通路的迷宫:
依然使用栈进行压栈，出栈(回溯)操作，此时在程序内另外开辟一个shortPath用来保存最短路程。path用来保存每一次的通路路程。每找到一条通路就用path和shortPath比较，如果path比shortPath更短，则将path赋值给shortPath。
这里写图片描述
其中蓝色路线是shortPath中所保存的最短路程。
对于带有环的迷宫：
这里写图片描述
如果用之前的代码会发现，程序保存的最短路程将会是。
这里写图片描述
并不是我们所期待的最短路了。
此时之前的2标记法已经不再够用，通路的判别方式也需要改变。
1.现在让入口的标记为2，之后每一个通路点都是前一个点+1。
2.判断通路的条件改为 

if (((next._row < M&&next._col < N)&&(_maze[next._row][next._col] == 0))||(_maze[cur._row][cur._col]<_maze[next._row][next._col]))
//不越界&&有通路 || 下一个点的坐标值大于当前点的坐标值

此时的通路应该为：
这里写图片描述
程序走过的路程为：
这里写图片描述
这边是迷宫的最终版本
实现：

template <size_t M, size_t N>
class Maze
{
public:
    Maze(int maze[][N]);    //初始化一个迷宫
    void Print();   //打印迷宫
    bool CheckAccess(Pos cur,Pos next) {   //判断该点是否合法
                                   //不溢出或者有通路返回真
        if (((next._row < M&&next._col < N)&&(_maze[next._row][next._col] == 0))||(_maze[cur._row][cur._col]<_maze[next._row][next._col]))
            return true;
        return false;
    }
    void GetPath(Pos entry, stack<Pos>&path) {    //找出口   //传入一个path用来记录路程
        Pos cur = entry;

        path.push(entry);  //将起点压栈
        if (cur._row == M - 1) {
            if (shortPath.empty() || shortPath.size() > path.size()) {   //如果最短路程为空或大于则赋值
                shortPath = path;
            }
            path.pop();
            return;
        }
        //顺时针排查

        Pos next;

        next = entry;  //next指向当前位置
        next._row -= 1;    //上
        if (CheckAccess(cur,next)) {   //检验上方是否有通路
            _maze[next._row][next._col] = _maze[entry._row][entry._col] + 1;
            GetPath(next, path);//如果符合则压栈
        }

        next = entry;        //next指向当前位置
        next._col += 1;    //右
        if (CheckAccess(cur,next)) {   //检验右方是否有通路
            _maze[next._row][next._col] = _maze[entry._row][entry._col] + 1;
            GetPath(next, path);//如果符合则压栈
        }

        next = entry;        //next指向当前位置
        next._row += 1;    //下
        if (CheckAccess(cur,next)) {   //检验下方是否有通路
            _maze[next._row][next._col] = _maze[entry._row][entry._col] + 1;
            GetPath(next, path);//如果符合则压栈
        }

        next = entry;        //next指向当前位置
        next._col -= 1;    //左
        if (CheckAccess(cur,next)) {   //检验左方是否有通路
            _maze[next._row][next._col] = _maze[entry._row][entry._col] + 1;
            GetPath(next, path);//如果符合则压栈
        }
        path.pop();  //如果以上4个都不符合 证明走到死路  利用后进先出的特点进行回溯
    }
protected:
    int _maze[M][N];
    stack<Pos> shortPath;   //创建一个栈对象 记录最短行程
};

template <size_t M, size_t N>
Maze<M, N>::Maze(int maze[][N]) {   //初始化迷宫
    for (size_t i = 0; i < M; i++) {
        for (size_t j = 0; j < N; j++) {
            _maze[i][j] = maze[i][j];
        }
    }
}
template <size_t M, size_t N>
void Maze<M, N>::Print() {          //打印迷宫
    for (size_t i = 0; i < M; i++) {
        for (size_t j = 0; j < N; j++) {
            cout << _maze[i][j] << "  ";
        }
        cout << endl;
    }
    cout << endl;
}
void test() {
    int mazeA[10][10] = {
        { 1,1,1,1,1,1,1,1,1,1 },
        { 1,1,1,1,1,1,1,1,1,1 },
        { 2,0,0,1,1,1,1,1,1,1 },  //令入口直接为2更方便
        { 1,1,0,1,1,1,1,1,1,1 },
        { 1,1,0,0,0,1,1,1,1,1 },
        { 1,1,0,1,0,1,1,1,1,1 },
        { 1,1,0,0,0,1,1,1,1,1 },
        { 1,1,0,1,1,1,1,1,1,1 },
        { 1,1,0,1,1,1,1,1,1,1 },
        { 1,1,0,1,1,1,1,1,1,1 }
    };
    Maze<10, 10>maze(mazeA);
    maze.Print();
    Pos entry = { 2,0 };
    stack<Pos>path;
    maze.GetPath(entry, path);
    maze.Print();
}
胡小哲
关注
专栏目录
用栈和递归求解迷宫问题
xxpresent的博客
11-30 1万+
一、问题概述 小时候，我们都玩过走迷宫的游戏吧。看一下这个图例： 遇到这种问题时，我们第一反应都会先找到迷宫的入口点，然后对上下左右四个方向进行寻迹，  检测当前位置是否是通路，是否可以通过，直至找到出口位置，才是迷宫的正确轨迹。如若走到死胡  同里，则必须返回重新选择路径走。  我们来模拟一下迷宫问题，我们的迷宫是这样的： 哈哈~虽然有点low！但是可以帮助我们解决实
递归解决迷宫问题
12-22
数据结构中递归是一个重要的部分，此程序是回溯法实现了迷宫的问题，比较简单，亲自测试成功。
使用递归解决迷宫问题
sinat_31089473的博客
07-30 445
使用二维数组来模拟迷宫， 重点是setWay方法的理解 //使用递归解决迷宫问题 //1.使用二维数组模拟迷宫 //2. setWay() public class MiGong { public static void printArray(int [][] a){ for(int row[]:a){ for(int col:row){ System.out.print(col+" ");
栈和递归---解决迷宫问题
angry_youth的博客
07-22 606
迷宫问题:走过的路设置为2，未走过的路设置0，墙设置为1； - 解决方法一：栈stack将每次你所走过的路都push进入栈里面，栈顶元素的坐标就是你所在的位置，取出你所在的位置然后判断当前位置上下左右四个方向是否有通路，如果没有就pop()顶层元素，然后再取出顶层元素（即退一步），然后接着判断其他方向是否有通路，直到你走出边界或者栈为空的时候退出； 缺陷：只找到一条路径就退出，无法判断最短路
递归法求解迷宫问题
boozergj的专栏
06-11 1971
<br />      求迷宫中从入口到出口的所有路径是一个经典的问题，这里所使用的方法是递归法，什么是递归呢？函数中有调用自己的函数，我们称为递归函数。一个问题可以分解为一个与自身求解过程相同的小问题，我们都可以用递归，比如，Hanoi塔问题，八皇后问题。我们知道用递归方法求解问题时最关键的就是递归函数的设计，在设计递归函数时应该注意以下几点：<br />     1.严格定义函数的功能和接口，对函数中所得的和原问题性质相同的子问题，只要接口一致，便可进行递归调用；<br />     2.对函数中每个递
用递归解决迷宫问题
weixin_42379941的博客
03-07 286
1.问题 图片描述:红色区域表示挡板,小球得到的路径与设置的找路策略有关 2.代码演示 package com.itguigu.recursion; public class MiGong { public static void main(String[] args) { // 1.创建一个二维数组表示地图map int[][] map = new i...
链式栈实现递归和非递归迷宫路径求解
07-11
递归解决方案则直接利用函数调用栈，每次进入新的节点，都进行一次函数调用，当到达出口或无路可走时，返回上一层。递归方法简洁直观，但可能导致大量重复计算，尤其是当迷宫路径复杂时。在Java中，可以定义一个递归...
迷宫问题的非递归算法(栈实现.rar_迷宫 栈_迷宫 问题 非递归 算法_迷宫 非递归_迷宫问题_迷宫问题栈
09-21
在本主题中，我们将重点讨论如何利用非递归算法，特别是栈数据结构来解决迷宫问题。 首先，栈是一种后进先出（LIFO）的数据结构，适用于解决需要回溯的问题，例如深度优先搜索（DFS）。在迷宫问题中，我们可以将栈...
递归和非递归解决迷宫问题
11-28
以一个m×n的长方阵表示迷宫，0和1分别表示迷宫中的通路和障碍，设计一个程序，对任意设定的迷宫，求出一条从入口到出口的通路，或得出没有通路的结论。 2、基本要求： （1）以链栈作为存储结构，编写一个求解迷宫的...
利用栈和队列解决迷宫问题
最新发布
05-31
3.实现链栈的基本操作：栈在本实验中用于记录解决迷宫的路径，要实现基本的初始化、入栈、出栈和判空等操作。 4.实现链式队列的基本操作：bfs算法借助队列实现迷宫路径的查找，所以要实现基本的初始化、入队、出队等...
递归法解决迷宫问题
04-26
此代码展示了一种用递归解决迷宫问题的方法，可以自行输入迷宫即得到解答
迷宫问题的递归解决办法
07-26
把主函数写的比较简，方便大家根据具体情况要求，进行改动~
迷宫问题（栈及递归两种实现方式）
06-22
迷宫问题：两种实现方式 1）递归实现：简易，但效率低，时间、空间时间复杂度较大 2）栈实现，时间空间复杂度较低
利用递归解决迷宫问题
orang_e的博客
07-14 256
利用递归解决迷宫问题
递归 递归解决迷宫问题
Foools的博客
03-04 461
递归 本质上就是自己调用自己，每次调用的时候传入不同的变量。 递归调用规则： 程序每执行到一个方法时，就会开辟一个独立的空间（栈） 每个空间的数据（局部变量），是独立的 一个方法执行完毕之后，或者遇到return，就会返回，谁调用，结果返回给谁。 递归迷宫问题 我们要使用递归的方法将下列map[1] [1]走到map[5] [4]。 思路分析： 数组中，1代表墙，2代表走过的路径，3代表死胡同，不要走 1） 创建一个二维数组作为map 2） 创建一个boolean类型的递归 a)
递归算法解决“迷宫”问题
m0_46405589的博客
11-26 1219
递归-迷宫问题 代码思路 使用二维数组 map[][] 模拟迷宫 约定： 当 map[i][j] 为 0 表示该点没有走过 ；当为 1 表示墙；2 表示通路可以走 ；3 表示该点已经走过，但是走不通 setWay() 方法用于找路，true 表示该路可以走通，false 表示该路走不通 在走迷宫时，需要确定一个策略(方法) 下->右->上->左 , 一步一步向前试探，如果该点走不通，再回溯 每当走到一个点时，将该点置为 2 ，暂时假设该路能走通，至于到底走不走得通，得看后面有没有找
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值