【数据结构】递归解决迷宫问题

最新推荐文章于 2024-04-27 18:02:39 发布
最新推荐文章于 2024-04-27 18:02:39 发布
阅读量3k 收藏 58
点赞数 5
分类专栏： 数据结构 栈 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40839718/article/details/124821822
版权

递归解决迷宫问题

1、递归的基本知识

1.1 递归的概念

方法自己调用自己，每次调用时传入不同的变量，递归有助于解决复杂的问题，同时可以让代码变得简洁。

1.2 递归的应用场景

(1) 各种数学问题：八皇后问题、汉诺塔、阶乘、迷宫问题、球和篮子问题；
(2) 各种算法中也会使用到递归，比如：快排、归并排序、二分查找、分治算法等；
(3) 用栈解决的问题。

1.3 递归需要遵守的重要规则

(1) 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)；
(2) 方法的局部变量是独立的，不会相互影响, 比如n变量；
(3) 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据；
(4) 递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError；
(5) 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

2、递归解决迷宫问题

在这里插入图片描述

2.1 代码编写

（1）创建一个二维数组，模拟迷宫,使用1表示墙

//创建一个二维数组，模拟迷宫,使用1表示墙
        int[][] map = new int[8][7];
        //上下全部置为1
        for (int j = 0; j < 7; j++) {
            map[0][j] = 1;
            map[7][j] = 1;
        }
        //左右全部置为1
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        //中间两个挡板
        map[3][1] = 1;
        map[3][2] = 1;
        //输出迷宫地图
        for (int i = 0; i < 8; i++) {
            for(int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }

在这里插入图片描述
（2）使用递归回溯来给小球找路
① map表示地图，(i,j)表示从地图出发的起点位置，
② map[i][j]=0表示该点没有走过；map[i][j]=1表示为墙6；map[i][j]=2表示通路可以走；map[i][j]=3表示该点已经走过，但是走不通；
③ 确定一个策略：下-》右-》上-》左，如果该点走不通，再回溯。

    //使用递归回溯来给小球找路，map表示地图，(i,j)表示从地图出发的起点位置，
    //map[i][j]=0表示该点没有走过；map[i][j]=1表示为墙6；map[i][j]=2表示通路可以走；map[i][j]=3表示该点已经走过，但是走不通；
    //确定一个策略：下-》右-》上-》左，如果该点走不通，再回溯。
    public static boolean setWay(int[][] map, int i, int j) {
        if (map[6][5] == 2) {//道路已经找到
            return true;

        }else {
            if (map[i][j] == 0) {//如果当前这个点还没有走过
                //假定该点是可以走通
                map[i][j] = 2;
                if (setWay(map, i + 1, j)) {//向下走
                    return true;
                } else if (setWay(map, i, j + 1)) {//向右走
                    return true;
                } else if (setWay(map, i - 1, j)) {//向上走
                    return true;
                } else if (setWay(map, i, j - 1)) {//向左走
                    return true;
                }
             else {
                //说明该点走不通，是死路
                map[i][j] = 3;
                return false;
            }
        }
            else{
                //如果map[i][j] != 0，可能是1,2,3
                return false;
            }
        }
    }

（3）编写主函数，给小球找路，并输出小球走过后标识的地图

 //使用递归回溯给小球找路
        setWay(map,1,1);
        //输出新的地图，即小球走过的路
        System.out.println("====输出小球走过后标识的地图====");
        for (int i = 0; i < 8; i++) {
            for(int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }

2.2 运行结果

在这里插入图片描述

3、最短路径

（1）策略：下-》右-》上-》左——9步
在这里插入图片描述
（2）策略：右-》上-》左-》下——9步
在这里插入图片描述
（3）策略：上-》左-》下-》右——12步
在这里插入图片描述
（4）策略：左-》下-》右-》上——12步
在这里插入图片描述
综上，采用策略：下-》右-》上-》左和策略：右-》上-》左-》下，小球走过的路径最短，最短路径步数为9步。

4、 完整代码

public class Migong {
    public static void main(String[] args) {
        //创建一个二维数组，模拟迷宫,使用1表示墙
        int[][] map = new int[8][7];
        //上下全部置为1
        for (int j = 0; j < 7; j++) {
            map[0][j] = 1;
            map[7][j] = 1;
        }
        //左右全部置为1
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        //中间两个挡板
        map[3][1] = 1;
        map[3][2] = 1;
        //输出迷宫地图
        System.out.println("====输出迷宫地图====");
        for (int i = 0; i < 8; i++) {
            for(int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }

        //输出新的地图，即小球走过的路
        /*System.out.println("====采用策略：下-》右-》上-》左，输出小球走过后标识的地图====");
        //使用递归回溯给小球找路
        setWay(map,1,1);
        for (int i = 0; i < 8; i++) {
            for(int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }*/

        /*System.out.println("====采用策略：右-》上-》左-》下，输出小球走过后标识的地图====");
        setWay2(map,1,1);
        for (int i = 0; i < 8; i++) {
            for(int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }*/

        System.out.println("====采用策略：上-》左-》下-》右，输出小球走过后标识的地图====");
        setWay3(map,1,1);
        for (int i = 0; i < 8; i++) {
            for(int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }

       /* System.out.println("====采用策略：左-》下-》右-》上，输出小球走过后标识的地图====");
        setWay4(map,1,1);
        for (int i = 0; i < 8; i++) {
            for(int j = 0; j < 7; j++) {
                System.out.print(map[i][j]+" ");
            }
            System.out.println();
        }*/
    }

    //使用递归回溯来给小球找路，map表示地图，(i,j)表示从地图出发的起点位置，
    //map[i][j]=0表示该点没有走过；map[i][j]=1表示为墙6；map[i][j]=2表示通路可以走；map[i][j]=3表示该点已经走过，但是走不通；
    //确定一个策略：下-》右-》上-》左，如果该点走不通，再回溯。
    public static boolean setWay(int[][] map, int i, int j) {
        if (map[6][5] == 2) {//道路已经找到
            return true;

        }else {
            if (map[i][j] == 0) {//如果当前这个点还没有走过
                //假定该点是可以走通
                map[i][j] = 2;
                if (setWay(map, i + 1, j)) {//向下走
                    return true;
                } else if (setWay(map, i, j + 1)) {//向右走
                    return true;
                } else if (setWay(map, i - 1, j)) {//向上走
                    return true;
                } else if (setWay(map, i, j - 1)) {//向左走
                    return true;
                }
             else {
                //说明该点走不通，是死路
                map[i][j] = 3;
                return false;
            }
        }
            else{
                //如果map[i][j] != 0，可能是1,2,3
                return false;
            }
        }
    }
    //使用递归回溯来给小球找路，map表示地图，(i,j)表示从地图出发的起点位置，
    //map[i][j]=0表示该点没有走过；map[i][j]=1表示为墙6；map[i][j]=2表示通路可以走；map[i][j]=3表示该点已经走过，但是走不通；
    //确定一个策略：右-》上-》左-》下，如果该点走不通，再回溯。
    public static boolean setWay2(int[][] map, int i, int j) {
        if (map[6][5] == 2) {//道路已经找到
            return true;

        }else {
            if (map[i][j] == 0) {//如果当前这个点还没有走过
                //假定该点是可以走通
                map[i][j] = 2;
                if (setWay(map, i , j+1)) {//向右走
                    return true;
                } else if (setWay2(map, i-1, j )) {//向上走
                    return true;
                } else if (setWay2(map, i, j-1)) {//向左走
                    return true;
                } else if (setWay2(map, i+1, j )) {//向下走
                    return true;
                }
                else {
                    //说明该点走不通，是死路
                    map[i][j] = 3;
                    return false;
                }
            }
            else{
                //如果map[i][j] != 0，可能是1,2,3
                return false;
            }
        }

    }
    //使用递归回溯来给小球找路，map表示地图，(i,j)表示从地图出发的起点位置，
    //map[i][j]=0表示该点没有走过；map[i][j]=1表示为墙6；map[i][j]=2表示通路可以走；map[i][j]=3表示该点已经走过，但是走不通；
    //确定一个策略：上-》左-》下-》右，如果该点走不通，再回溯。
    public static boolean setWay3(int[][] map, int i, int j) {
        if (map[6][5] == 2) {//道路已经找到
            return true;

        }else {
            if (map[i][j] == 0) {//如果当前这个点还没有走过
                //假定该点是可以走通
                map[i][j] = 2;
                if (setWay(map, i-1 , j)) {//向上走
                    return true;
                } else if (setWay3(map, i, j-1 )) {//向左走
                    return true;
                } else if (setWay3(map, i+1, j)) {//向下走
                    return true;
                } else if (setWay3(map, i, j+1 )) {//向右走
                    return true;
                }
                else {
                    //说明该点走不通，是死路
                    map[i][j] = 3;
                    return false;
                }
            }
            else{
                //如果map[i][j] != 0，可能是1,2,3
                return false;
            }
        }

    }

    //使用递归回溯来给小球找路，map表示地图，(i,j)表示从地图出发的起点位置，
    //map[i][j]=0表示该点没有走过；map[i][j]=1表示为墙6；map[i][j]=2表示通路可以走；map[i][j]=3表示该点已经走过，但是走不通；
    //确定一个策略：左-》下-》右-》上，如果该点走不通，再回溯。
    public static boolean setWay4(int[][] map, int i, int j) {
        if (map[6][5] == 2) {//道路已经找到
            return true;

        }else {
            if (map[i][j] == 0) {//如果当前这个点还没有走过
                //假定该点是可以走通
                map[i][j] = 2;
                if (setWay(map, i , j-1)) {//向左走
                    return true;
                } else if (setWay4(map, i+1, j )) {//向下走
                    return true;
                } else if (setWay4(map, i, j+1)) {//向右走
                    return true;
                } else if (setWay4(map, i-1, j )) {//向上走
                    return true;
                }
                else {
                    //说明该点走不通，是死路
                    map[i][j] = 3;
                    return false;
                }
            }
            else{
                //如果map[i][j] != 0，可能是1,2,3
                return false;
            }
        }

    }
}
dengmsjava
关注
  • 5
    点赞
  • 踩
  • 58
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python基于递归算法实现的走迷宫问题
09-21
主要介绍了Python基于递归算法实现的走迷宫问题,结合迷宫问题简单分析了Python递归算法的定义与使用技巧,需要的朋友可以参考下
[C语言、C++]数据结构作业：用递归实现走迷宫(打印正确通路即可)
Yhisken的博客
11-06 1668
[C语言、C++]数据结构作业：用递归实现走迷宫(打印正确通路即可)
递归法解决迷宫问题
04-26
此代码展示了一种用递归解决迷宫问题的方法，可以自行输入迷宫即得到解答
递归解决迷宫问题
12-22
数据结构中递归是一个重要的部分，此程序是回溯法实现了迷宫的问题，比较简单，亲自测试成功。
递归-迷宫问题（回溯）
方亚军的博客
12-24 3176
递归 在定义一个函数时，出现直接或间接调用自己的成分，称之为递归。 递归算法解决问题的特点： 1 .递归就是方法里调用自身。 2. 在使用递增归策略时，必须有一个明确的递归结束条件，称为递归出口。 3. 递归有助于编程者解决复杂的问题（如迷宫问题，汉诺塔等），同时可以让代码变得简洁 递归需要遵守的重要规则 执行一个方法时，就是创建一个新的受保护的独立空间（栈空间） 方法的局部变量是独立的，...
递归经典问题：迷宫以及八皇后
qq_54469537的博客
06-29 197
回溯算法：八皇后和迷宫问题
递归算法解决“迷宫”问题
m0_46405589的博客
11-26 1143
递归-迷宫问题 代码思路 使用二维数组 map[][] 模拟迷宫 约定： 当 map[i][j] 为 0 表示该点没有走过 ；当为 1 表示墙；2 表示通路可以走 ；3 表示该点已经走过，但是走不通 setWay() 方法用于找路，true 表示该路可以走通，false 表示该路走不通 在走迷宫时，需要确定一个策略(方法) 下->右->上->左 , 一步一步向前试探，如果该点走不通，再回溯 每当走到一个点时，将该点置为 2 ，暂时假设该路能走通，至于到底走不走得通，得看后面有没有找
40、迷宫求解----递归实现
hopegrace的博客
02-23 1202
一、问题的分析： 本问题的求解，关键是如何找到求解任意两个点间，按照以上基本思想而走出的路线。按照这个路线，我们可以通过图形函数来动态的显示迷宫的搜索过程。 计算机解迷宫解通常用的是“穷举求解”方法，即从入口出发，顺着某一个方向进行探索，若能走通，则继续往前进，否则沿着原路退回，换一个方向继续探索，直至出后位置，求得一条通路。假如所有可能的通路都探索到位能到达出口，则所设定的迷宫没有通路...
递归、回溯、队列三种方式求解迷宫问题
lslslslslss的博客
12-03 2940
迷宫问题是机器智能中一种常见的问题，我们在生活中也会常常遇到这类问题:我们会顺着某一方向向前探索,如果遇到岔口,则要选择某一个路口前进,会出现两种可能性,若能走通,则继续往前走，最后顺利通到出口处;否则沿原路退回,换一个方向在继续探索，直至所有可能的通路都探索到为止。 用问题定义可以描述为迷宫是一个M*N的二维矩阵,其中0为墙,1为路,入口在第一列，出口在最后一列。要求从入口开始，从出口结束,按照上,下，左,右的顺序来搜索路径，设计程序，对任意设定的迷宫，求出从入口到出口的...
Java递归详解_动力节点Java学院
f5465245的博客
09-12 409
递归算法是一种直接或者间接调用自身函数或者方法的算法。Java递归算法是基于Java语言实现的递归算法。递归算法的实质是把问题分解成规模缩小的同类问题的子问题，然后递归调用方法来表示问题的解。递归算法对解决一大类问题很有效，它可以使算法简洁和易于理解。     递归算法解决问题的特点：     1）递归就是方法里调用自身。 　 2） 在使用递增归策略时，必须有一个明确的递归结束条件，称为递归
迷宫游戏C++数据结构递归算法实现
03-08
在学习数据结构中自己实现的迷宫游戏。这个代码中有迷宫生成（迷宫比较不错），然后对生成的迷宫用递归算法寻找路径。在迷宫设计以及递归学习是个不错的选择。
【Java数据结构与算法】 递归及迷宫问题（回溯）
01-20
文章目录递归调用机制简单的递归使用递归能解决的问题和规则递归-迷宫问题思路分析：代码如下： 递归调用机制 简单地说：递归就是方法自己调用自己，每次调用时传入不同的变量，递归有助于编程者解决复杂的问题，...
递归和非递归解决迷宫问题
11-28
（1）以链栈作为存储结构，编写一个求解迷宫的非递归程序，并将求得的通路以三元组（i,j,d）的形式输出，其中： i,j指示迷宫中的一个坐标，d表示走到下一坐标的方向； （2）编写递归形式的算法，求得迷宫中所有可能...
数据结构迷宫问题代码.pdf
11-16
数据结构迷宫问题代码 在这个迷宫问题中，我们将使用深度优先搜索(DFS)策略。迷宫是一个二维数组，0表示可以通过的地方，1表示墙壁不能通过的地方。我们的目标是找到从起点(start)到终点(end)的路径。 这是使用...
【数据结构】三、栈和队列：2.顺序栈&共享栈（顺序栈的初始化，判空，进栈，出栈，读取栈顶，顺序栈实例）
来csdn只办三件事：开源！开源！还是***开源！
04-23 1190
因为顺序栈的缺点是栈的大小不可变，所以引出共享栈，两个栈共享一片空间。这片存储空间不单独属于任何一个栈，某个栈需要的多一点，它就可能得到更多的存储空间。两个栈的栈底在这片存储空间的两端，当元素入栈时，两个栈的栈顶指针相向而行。当他们下一个指针的位置在一起时，说明这个栈已经放满元素。C++是一门面向对象的高级语言，在我们编写代码中，常常离不开对对象的创建和清理对象资源。指向栈顶元素，一般存储的是数组的下标。top当前指向的位置是栈顶上面的一个没有元素的空位置。如果有abcde，5个元素，那么满栈top=4。
【Redis 开发】(Feed流的模式，GEO数据结构，BitMap,HyperLogLog)
最新发布
weixin_62513677的博客
04-27 566
如果我们需要统计UV值，我们可以使用HyperLogLog，它是从LogLog算法中派生出来的概率算法，用于确定非常大的集合的基数，但是它的单个存储的统计内存永远小于16kb，但是代价就是统计是概率性的有小于0.81%的误差，不过可以忽略。也叫做写扩散，发布的消息不需要写入到发件箱中，直接推送到被关注人的收件箱中并通过时间戳进行排序，延时低，但是比如说微博中的一些大V，粉丝人特别多，这样就会写很多。范围可以是圆形或矩形。:指定圆心、半径，找到该圆内包含的所有member，并按照与圆心之间的距离排序后返回。
数据结构中的串（String）：概念、操作和实际应用
JAZJD的博客
04-24 982
在计算机科学中，串 是由零个或多个字符组成的有限序列，是数据结构中常见的一种基本类型。它可以为空串，也可以是由字符组成的非空串。串通常用于表示文本数据，如文件内容、用户输入等，因此在算法和程序设计中占据着重要的地位。一个串可以是由字母、数字、符号等任意字符组成，字符的种类和个数没有固定限制。例如，"Hello, World!@#$%" 都是串的例子。串的重要性在于它是对文本数据进行处理和操作的基础，涉及字符串匹配、文本编辑、编译器设计等多个领域。因此，深入理解串的特性和操作对于程序设计人员至关重要。
数据结构-树和森林之间的转化
2302_80729149的博客
04-23 381
这里我们根据左儿子右爸爸的逻辑将每个子树转化为二叉树的形式，对于第一个树，b，c，d都是a的儿子，所以都放到a的左边，而bcd之间也是兄弟关系，一起放到右边，然后再将三个树转化完毕后依次相连，构成二叉树的形式。从树的二叉链表的定义可知，任何一棵和树对应的二叉树，其根节点的右子树必为空。这里我们举三个树，将这个由三个树组成的森林组成二叉树是这个样子的。下面我们说明一下详细过程，首先将每个树转化为二叉的状态，如图所示。
【大数据】LSM树，专为海量数据读写而生的数据结构
Joker_ZJN的博客
04-24 1025
一文详聊LSM树这种专为海量数据读写而生的数据结构
数据结构递归迷宫问题
08-19
### 回答1： 递归解决迷宫问题是一种常见的方法。在这种方法中，我们使用递归函数来探索迷宫中的每个可能的路径，直到我们找到出口或确定没有解决方案为止。 首先，我们需要定义一个迷宫。可以使用一个二维数组来表示迷宫，其中 0 表示可以通过的位置，1 表示障碍物或墙。 接下来，我们需要定义一个递归函数，该函数将从当前位置开始探索迷宫。在每个位置上，我们检查是否已到达出口，如果是，则返回真。否则，我们尝试从当前位置向四个方向移动，并递归地调用该函数以继续探索。如果在任何方向上找到了出口，则返回真。如果没有找到出口，则返回假。 以下是一个可能的解决方案（使用 C++ 实现）： ```cpp #include <iostream> using namespace std; const int N = 5; int maze[N][N] = { {0, 1, 0, 0, 0}, {0, 1, 0, 1, 0}, {0, 0, 0, 0, 0}, {0, 1, 1, 1, 0}, {0, 0, 0, 1, 0} }; bool solve(int x, int y) { if (x == N-1 && y == N-1) { // 到达出口 return true; } if (x < 0 || y < 0 || x >= N || y >= N) { // 超出边界 return false; } if (maze[x][y] == 1) { // 遇到障碍物 return false; } maze[x][y] = 1; // 标记为已访问 if (solve(x+1, y) || solve(x-1, y) || solve(x, y+1) || solve(x, y-1)) { return true; // 向四个方向递归查找 } maze[x][y] = 0; // 恢复为未访问 return false; // 没有找到出口 } int main() { if (solve(0, 0)) { cout << "迷宫有解！" << endl; } else { cout << "迷宫无解。" << endl; } return 0; } ``` 在上面的代码中，我们首先从起点 (0, 0) 开始调用 solve() 函数。在 solve() 函数中，我们按顺序检查当前位置是否为出口、是否超出边界、是否遇到障碍物。如果都不是，则标记当前位置为已访问，并向四个方向递归调用 solve() 函数以继续探索。如果在任何方向上找到出口，则返回真。如果没有找到出口，则恢复当前位置为未访问状态，并返回假。 在主函数中，我们检查 solve() 函数的返回值以确定迷宫是否有解。如果有解，则输出“迷宫有解！”；否则，输出“迷宫无解。”。 需要注意的是，这种方法可能会导致栈溢出，因为每个递归调用都会将一个新的栈帧压入堆栈中。为了避免这种情况，可以使用迭代加深搜索或其他更高级的搜索算法。 ### 回答2： 数据结构递归算法可以用于解决迷宫问题。迷宫问题是在一个矩阵中找到从起点到终点的路径。矩阵可以表示为一个二维数组，其中0表示可通行的路径，1表示墙壁或障碍物。我们需要找到一条从起点到终点的路径，路径可以相邻的上下左右移动。 使用递归算法可以很方便地解决迷宫问题。我们可以从起点开始，每次选择一个方向前进，并通过递归调用来继续探索下一步是否可行。若当前位置为终点，则找到了一条路径，返回true。若当前位置已经走过或者是墙壁，则返回false。若当前位置是可通行路径，则继续向四个方向递归调用，直到找到一条可行路径或者所有方向都走过一遍。 通过递归算法，我们可以遍历所有可能的路径，直到找到一条通往终点的路径或者确定没有可行路径为止。算法的基本思路是不断向前探索并回溯，重复这个过程直到找到结果。 递归算法在解决迷宫问题时可以使用栈来保存之前的路径，并在回溯时将路径出栈，以便返回上一步。同时，为了避免重复探索，需要使用一个二维数组来记录每个位置是否已经走过。 总之，使用数据结构递归算法可以很好地解决迷宫问题。该算法的时间复杂度取决于迷宫的大小和难度，但在一般情况下是可以接受的。 ### 回答3： 数据结构中的递归在解决迷宫问题中非常有用。迷宫问题是一个典型的寻路问题，目标是从迷宫的起点找到一条通往终点的路径。 在数据结构中，可以使用递归来解决这个问题。我们可以将迷宫看作是一个二维数组，每个元素表示一个迷宫的单元格。其中，0代表可通过的通道，1代表墙壁或障碍物。 首先，我们需要定义一个递归函数，用来找到从当前位置到终点的路径。该函数的输入参数包括当前位置的行和列，以及表示迷宫的二维数组。递归的结束条件就是当前位置已经是终点，即到达了目标位置。 在每一步递归中，我们需要检查当前位置的上、下、左、右四个方向是否可以移动。如果某个方向可以移动，我们就将下一步的位置设为该方向，并调用递归函数。如果递归函数返回真，表示找到了一条有效路径，我们就返回真；否则，我们需要回溯到上一步，并继续尝试其他方向。 在递归函数中，还需要有一个标记数组来记录已经访问过的位置，避免重复访问。每次需要访问一个位置时，我们首先检查该位置是否超出了迷宫的边界，并且该位置没有被访问过。如果满足这两个条件，我们将该位置标记为已访问，并继续递归。 如果递归函数返回真，表示找到了一条有效路径，我们可以将该路径输出或保存下来。如果递归函数返回假，并且没有其他方向可以继续尝试，表示无法找到有效路径，我们就返回假。 数据结构中的递归在解决迷宫问题上是非常高效的，因为它能够自动探索所有可能的路径，而不需要编写复杂的循环代码。通过合理的设计递归函数和标记数组，我们能够有效地解决迷宫问题，并找到一条通往终点的路径。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值