数据结构与算法之递归解决迷宫及八皇后问题

最新推荐文章于 2023-12-02 15:04:04 发布
最新推荐文章于 2023-12-02 15:04:04 发布
阅读量160 收藏 1
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 递归 迷宫 八皇后
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hcyxsh/article/details/116749561
版权

数据结构与算法之递归解决迷宫及八皇后问题

一 迷宫问题

  1. 迷宫问题描述
    从左上角走到右下角，红色代表墙，白色代表可以走
    在这里插入图片描述
  2. 思路
    （1）使用二维数组构建地图map，i,j代表位置，（1,1）代表出发的地址，（6,5）代表目的地
    （2）约定：数字1代表墙，2代表走通的路，3代表走过回溯走不通
    （3）走路策略：下-> 右->上 -> 左或其他的策略
  3. 代码实现
package com.datastrucate.recursion;

/**
 * ClassName:MiGong
 * Package:com.datastrucate.recursion
 * Description:
 *
 * @Date:2021/5/13 14:36
 * @Author:hm
 */
public class MiGong {

    public static void main(String[] args) {
        // 先创建一个二维数组，模拟迷宫
        // 地图
        int[][] map = new int[8][7];
        // 使用1 表示墙
        // 上下全部置为1
        for (int i = 0; i < 7; i++) {
            map[0][i] = 1;
            map[7][i] = 1;
        }

        // 左右全部置为1
        for (int i = 0; i < 8; i++) {
            map[i][0] = 1;
            map[i][6] = 1;
        }
        //设置挡板, 1 表示
        map[3][1] = 1;
        map[3][2] = 1;
//		map[1][2] = 1;
//		map[2][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();
        }

        //使用递归回溯给小球找路
        //setWay(map, 1, 1);
        setWay2(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();
        }

    }

    //使用递归回溯来给小球找路
    //说明
    //1. map 表示地图
    //2. i,j 表示从地图的哪个位置开始出发 (1,1)
    //3. 如果小球能到 map[6][5] 位置，则说明通路找到.
    //4. 约定： 当map[i][j] 为 0 表示该点没有走过 当为 1 表示墙  ； 2 表示通路可以走 ； 3 表示该点已经走过，但是走不通
    //5. 在走迷宫时，需要确定一个策略(方法) 下->右->上->左 , 如果该点走不通，再回溯
    /**
     *
     * @param map 表示地图
     * @param i 从哪个位置开始找
     * @param j
     * @return 如果找到通路，就返回true, 否则返回false
     */
    public static boolean setWay(int[][] map, int i, int j) {
        if(map[6][5] == 2) { // 通路已经找到ok
            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;
            }
        }
    }

    //修改找路的策略，改成 上->右->下->左
    public static boolean setWay2(int[][] map, int i, int j) {
        if(map[6][5] == 2) { // 通路已经找到ok
            return true;
        } else {
            if(map[i][j] == 0) { //如果当前这个点还没有走过
                //按照策略 上->右->下->左
                map[i][j] = 2; // 假定该点是可以走通.
                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 if (setWay2(map, i, j-1)){ // 向左走
                    return true;
                } else {
                    //说明该点是走不通，是死路
                    map[i][j] = 3;
                    return false;
                }
            } else { // 如果map[i][j] != 0 , 可能是 1， 2， 3
                return false;
            }
        }
    }
}

二 八皇后问题（回溯）

  1. 问题描述
    在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法(92)。
  2. 思路
    （1) 第一个皇后先放第一行第一列
    （2) 第二个皇后放在第二行第一列、然后判断是否 OK， 如果不 OK，继续放在第二列、第三列、依次把所有列都放完，找到一个合适
    （3) 继续第三个皇后，还是第一列、第二列……直到第 8 个皇后也能放在一个不冲突的位置，算是找到了一个正确解
    （4) 当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到.
    （5) 然后回头继续第一个皇后放第二列，后面继续循环执行 1,2,3,4 的步骤
    （6) 示意图:
    在这里插入图片描述
    说明：
    理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题. 例如其中一种方法：arr[8] ={0 , 4, 7, 5, 2, 6, 1, 3} //对应 arr 下标 表示第几行，即第几个皇后，arr[i] = val , val 表示第 i+1 个皇后，放在第 i+1 行的第 val+1 列
  3. 代码实现
package com.datastrucate.recursion;

/**
 * ClassName:Queue8
 * Package:com.datastrucate.recursion
 * Description:
 *
 * @Date:2021/5/13 15:49
 * @Author:hm
 */
public class Queue8 {

    //定义一个max表示共有多少个皇后
    int max = 8;
    //定义数组array, 保存皇后放置位置的结果,比如 arr = {0 , 4, 7, 5, 2, 6, 1, 3}
    int[] array = new int[max];
    static int count = 0;
    static int judgeCount = 0;
    public static void main(String[] args) {
        //测试一把 ， 8皇后是否正确
        Queue8 queue8 = new Queue8();
        queue8.check(0);
        System.out.printf("一共有%d解法", count);
        System.out.printf("一共判断冲突的次数%d次", judgeCount); // 1.5w

    }



    //编写一个方法检测八皇后放置策略
    //放置第n+1个皇后，比如n=0就是第一个皇后代表第一行
    //特别注意： check 是 每一次递归时，进入到check中都有  for(int i = 0; i < max; i++)，因此会有回溯
    private void check(int n) {
        if(n == max) {  //n = 8 , 其实8个皇后就既然放好
            print();
            return;
        }

        //依次放入皇后，并判断是否冲突，i表示列
        for(int i = 0; i < max; i++) {
            //先把当前这个皇后 n , 放到该行的第1列
            array[n] = i;
            //判断当放置第n个皇后到i列时，是否冲突
            if(judge(n)) { // 不冲突
                //接着放n+1个皇后,即开始递归
                check(n+1); //
            }
            //如果冲突，就继续执行 array[n] = i; 即将第n个皇后，放置在本行得 后移的一个位置
        }
    }

    //查看当我们放置第n个皇后, 就去检测该皇后是否和前面已经摆放的皇后冲突
    /**
     *
     * @param n 表示第n个皇后
     * @return
     */
    private boolean judge(int n) {
        judgeCount++;
        for(int i = 0; i < n; i++) {
            // 说明
            //1. array[i] == array[n]  表示判断 第n个皇后是否和前面的n-1个皇后在同一列
            //2. Math.abs(n-i) == Math.abs(array[n] - array[i]) 表示判断第n个皇后是否和第i皇后是否在同一斜线
            //3. 判断是否在同一行, 没有必要，n 每次都在递增
            if(array[i] == array[n] || Math.abs(n-i) == Math.abs(array[n] - array[i]) ) {
                return false;
            }
        }
        return true;
    }

    //写一个方法，可以将皇后摆放的位置输出
    private void print() {
        count++;
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        System.out.println();
    }

}
数据结构 5. 递归
小蜗牛的博客
05-15 525
Leetcode部分队列相关练习一、递归1. 递归的定义2. 递归的实现2.1 斐波那契数列求值2.2 编程实现求阶乘 n!2.3 编程实现一组数据集合的全排列3. 练习70. Climbing Stairs（爬楼梯）746. 使用最小花费爬楼梯 一、递归 1. 递归的定义 递归就是子程序（或函数）直接调用自己或通过一系列调用语句间接调用自己，是一种描述问题和解决问题的基本方法。 递归常与分治思想...
数据结构与算法 递归解决八皇后、迷宫问题
weixin_67773572的博客
11-09 280
递归是比较好理解的，递归是解决问题比较常用的一个算法。递归可以解决想八皇后、汉诺塔、走迷宫这样的问题。
java数据结构和算法——递归与迷宫和八皇后问题
qq_49922118的博客
03-13 179
递归迷宫问题八皇后问题 递归调用规则： 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)。 方法的局部变量是独立的，不会相互影响， 比如n变量。 如果方法中使用的是引用类型变量(比如数组)，就会共享该引用类型的数据。 递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError。 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。 迷宫问题 public class Maze {
数据 结构——递归
qq_20386411的博客
03-11 234
递归 递归不一定非要像斐波拉契数列一样在return中调用函数 递归的结束条件就是初始条件值 通常的方法将递归调用放在if语句中 n！通过递归实现（常用方法还是通过while实现） def jiecheng(n): if n==0: return 1 else: sum=n*jiecheng(n-1)#右边只有阶乘表达式，没有什么s...
递归-数据结构
weixin_42822452的博客
05-12 727
递归递归三要素斐波那契数列 递归的基本思想是某个函数直接或者间接地调用自身，这样就把原问题的求解转换为许多性质相同但是规模更小的子问题。我们只需要关注如何把原问题划分成符合条件的子问题，而不需要去研究这个子问题是如何被解决的。递归和枚举的区别在于：枚举是横向地把问题划分，然后依次求解子问题，而递归是把问题逐级分解，是纵向的拆分 递归三要素 1、明确递归终止条件； 2、给出递归终止时的处理办法； 3、提取重复的逻辑，找出函数的等价关系式。 斐波那契数列 斐波那契数列是一位意大利的数学家，他闲着没事去研究兔子繁
数据结构-递归
one-piece-luka的博客
04-25 138
1.什么情况下可以使用递归： 1）一个问题的解可以分解为几个子问题的解 2）这个问题分解之后的子问题，求解思路完全一样 3）一定有一个确定的答案，即递归的终止条件 2.以斐波那契数列为例： private static int[] data=new int[46]; /** * 递归 * @param n，元素个数 * @return */ ...
递归：迷宫与八皇后问题详解
本文主要聚焦于递归的应用场景，递归的概念，以及在迷宫问题和八皇后问题中的具体实现。 1. **递归应用场景** - **迷宫问题（回溯法）**：迷宫问题是一个经典的递归应用，例如寻找从起点到终点的路径。在这个例子...
数据结构与算法day13-递归运用之迷宫问题
深耕java的博客
12-31 366
说明： 1.小球得到的路径，和程序员设置的找路策略有关：找路的上下左右顺序相关 2.再得到小球路径时，可以先使用(下右上左)，再改成(上右下左)，看看路径 是不是有变化 3.测试回溯现象 4.思考：如何求出最短路径？ ...
韩顺平 数据结构与算法 （7）递归+八皇后问题
weixin_52184392的博客
10-14 401
递归（Recursion） 1） 递归的应用场景 迷宫问题 2）概念 递归就是方法自己调用自己，每次调用时传入不同的变量； 有助于编程者解决复杂的问题，同时可以让代码变得简洁 3）案例 代码演示—打印问题和阶乘问题 package DataStructures.Recursion; public class RecursionTest { public static void main(String[] args) { //打印问题，递归调用机制 test(4);
算法与数据结构体系课（java版，16周全）
11-17
《算法与数据结构体系课（Java版，16周全）》是一门全面深入学习算法与数据结构的课程，特别适合对计算机科学有兴趣或者正在学习软件开发的Java开发者。这门课程涵盖了从基础到高级的各种数据结构和算法，旨在提升...
数据结构——递归
lianghe77的博客
10-26 547
数据结构与算法（六）：递归 最近开始学习王争老师的《数据结构与算法之美》，通过总结再加上自己的思考的形式记录这门课程，文章主要作为学习历程的记录。 递归是一种非常高效、简洁的编码技巧，一种应用非常广泛的算法，比如DFS深度优先搜索、前中后序二叉树遍历等都是使用递归。基本上所有的递归问题都可以用递推公式来表示。以寻找电影排数为例，只需要问前一排人的排数，然后前一排的人再向前询问······用递推公式...
数据结构之递归
weixin_48589156的博客
05-13 1967
数据结构之递归 定义 所谓递归(Recursion),就是方法（函数）调用自身,对于递归来说,一定有一个出口,让递归结束,只有这样才能保证不出现死循环。 解析：A函数实现调用B函数(可以调用其他函数，也可以是自身） 当A函数运行时调用B函数时，在运行被调用函数B之前，系统需要先完成3件事： 1.将所有实参、返回地址等信息传递给被调用函数保存； 2.给被调函数的局部变量分配存储区； 3.将控制权转移到被调函数入口（既地址）。 当被调用函数执行完成之后，返回调用函数时之前，也需要完成3件事： 1.保存被调函数
【数据结构(五)】递归
最新发布
weixin_44883789的博客
12-02 179
arr[8] ={0 , 4, 7, 5, 2, 6, 1, 3} //对应 arr 下标 表示第几行，即第几个皇后，arr[i] = val , val 表示第 i+1 个皇后，放在第 i+1 行的第 val+1 列。八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。④当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到。（2）各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等.路径策略：下 --> 右 --> 上 --> 左。
JAVA数据结构之递归
sl1130398099的博客
03-31 280
package p03.递归; /* * 递归: * 1.函数调用函数自身，基于栈 * 2.但是不能无限调用，必须要有一个终点（结束点） * 3.递归不能解决深度过大(n)的问题 * 4.到底用不用递归？但凡是迭代的问题都可以用递归，但是不代表递归的问题可以用迭代解决。 * 5.用迭代是人，用递归是神。 * * 分治算法：是一种思想 * （分而治之，就是将一个更大的问题拆分 拆...
递归的理解（数据结构）
weixin_51578598的博客
09-26 2336
在数据结构中，很多内容都应用到递归，递归在数据结构中至关重要 递归定义：一个函数、概念或数学结构，如果在其定义或说明内部直接或间接地出现对其本身的引用，或者是为了描述问题的某一状态，必须要用至它的上一状态，而描述上一状态，又必须用到它的上一状态……这种用自己来定义自己的方法，称之为递归或递归定义。在程序设计中，函数直接或间接调用自己，就被称为递归调用。 递归的几个特点1.递归式，就是如何将原问题划分成子问题。 2.递归出口，递归终止的条件，即最小子问题的求解，可以允许多个出口。 3.界函数，问题
数据结构4--递归
温故知新
05-18 810
递归函数递归的概念递归的定义递归的特点递归过程与递归工作栈汉诺塔问题汉诺塔编程方法八皇后问题问题描述递归分析八皇后编程方法 递归的概念 递归的定义 若一个对象部分地包含它自己，或用它自己给自己定义,则称这个对象是递归的 若一个过程直接地或间接地调用自己，则称这个过程是递归的过程。 在以下三种情况，常常用到递归方法 定义是递归的 数据结构是递归的 问题的解法是递归的 递归的特点 递归的基本思想是 自己调用自己 例如： 数学上最常见、最简单的递归问题就是自然数的阶乘。 n=0， n!= 1; n&gt
数据结构递归的使用
0
03-03 1592
什么是递归? 递归是一种应用非常广泛的算法，因为它可以通过同一种算法不断低简单重复，这样可以把一个复杂的问题分解成很多层简单的问题。 递归实现原理? 递归的本质有三条：其一是自顶而下，其二是自己不断重复，其三是循环中的结束条件。 递归例子: 假如这里有 n 个台阶，每次你可以跨 1 个台阶或者2个台阶，请问走这n个台阶有多少种走法？如果有7个台阶,你可以2,2,2,1这样子上去,也可以1,2,1,...
学习笔记|数据结构——递归
weixin_43202834的博客
03-15 414
学习笔记|数据结构——递归 1、递归定义 方法或函数调用自身的方式成为递归调用 去的过程叫“递”，回来的过程叫“归” 2、递归需要满足的条件 1、一个问题可以分解为数据规模更小的问题。比如阶乘，只需要计算本身的值和前一个数的乘积 2、分解后的子问题，除数据规模不一样，求解思路完全相同。 3、存在递归终止条件。一般用 if() return… 来返回最初的几个特殊值 因此，编写递归程序最关键的是写出递推公式，找到终止条件，剩下将地推公式转换为代码就简单了 典型问题 爬楼梯问题 首先找到某一层与之前一层的关
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值