递归回溯之小老鼠出迷宫问题

直接看代码

/**
* @ClassName MiGong01
* @Description TODO
* @Author Orange
* @Date 2021/4/16 8:08
* @Version 1.0
**/
public class MiGong01 {
public static void main(String[] args) { int [][] map = new int [10][10]; //设置迷宫大小
for(int i = 0; i < map.length; i++) { //设置迷宫形状
for (int j =0; j < map[i].length; j++) {
map[0][j] = 1;
map[9][j] = 1; }
map[i][0] = 1;
map[i][9] = 1;
}
map[3][1] = 1; //设置迷宫障碍物的位置
map[3][2] = 1;
map[3][3] = 1;
map[3][4] = 1;
map[2][4] = 1;
map[2][5] = 1;
map[4][6] = 1;
map[5][5] = 1;
map[5][6] = 1;
map[5][7] = 1;
map[5][8] = 1;
map[6][4] = 1;
map[6][5] = 1;
map[7][4] = 1; System.out.println("=====当前地图情况======");
for(int i = 0; i < map.length; i++) {
for (int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " "); //输出一行
}
System.out.println();
} Find F1 = new Find();
//下右上左
F1.findWay(map, 1, 1);
System.out.println("\n==第三种找路的情况如下==");
for(int i = 0; i < map.length; i++) {
for(int j = 0; j < map[i].length; j++) {
System.out.print(map[i][j] + " "); //输出一行
}
System.out.println();
}
}
} class Find {
//使用递归回溯的思想来解决老鼠出迷宫
//1. findWay 方法就是专门来找出迷宫的路径
//2. 如果找到,就返回true ,否则返回false
//3. map 就是二维数组,即表示迷宫
//4. i,j 就是老鼠的位置,初始化的位置为(1,1)
//5. 因为我们是递归的找路,所以我先规定map 数组的各个值的含义
// 0表示可以走 1表示障碍物 2表示可以走 3表示走过,但是走不通是死路
//6. 当map[8][8] =2 就说明找到通路,就可以结束,否则就继续找.
//7. 先确定老鼠找路策略下->右->上->左
public boolean findWay(int[][] map , int i, int j) { if (map[8][8] == 2) { //说明已经找到
return true;
} else {
if (map[i][j] == 0) { //当前这个位置0,说明表示可以走
//我们假定可以走通
map[i][j] = 2;
//使用找路策略,来确定该位置是否真的可以走通
//下->右->上->左
if (findWay(map, i + 1, j)) { //先走下
return true;
} else if (findWay(map, i, j + 1)) { //右
return true;
} else if (findWay(map, i - 1, j)) { //上
return true;
} else if (findWay(map, i, j - 1)) { //左
return true;
} else {
map[i][j] = 3;
return false;
}
} else { //map[i][j] = 1 , 2, 3
return false;
}
}
}
//修改找路策略,看看路径是否有变化
//下->右->上->左==> 上->右->下->左
public boolean findWay2(int[][] map , int i, int j) {
if (map[8][8] == 2) { //说明已经找到
return true;
} else {
if (map[i][j] == 0) { //当前这个位置0,说明表示可以走
//我们假定可以走通
map[i][j] = 2;
//使用找路策略,来确定该位置是否真的可以走通
//上->右->下->左
if (findWay2(map, i - 1, j)) { //先走上
return true;
} else if (findWay2(map, i, j + 1)) { //右
return true;
} else if (findWay2(map, i + 1, j)) { //下
return true;
} else if (findWay2(map, i, j - 1)) { //左
return true;
} else {
map[i][j] = 3;
return false;
}
} else { //map[i][j] = 1 , 2, 3
return false;
}
}
} public boolean findWay3(int[][] map , int i, int j) { if (map[8][8] ==2) { //说明已经找到
return true;
} else {
if (map[i][j] == 0) { //当前这个位置0,说明表示可以走
//我们假定可以走通
map[i][j] = 2;
//使用找路策略,来确定该位置是否真的可以走通
//下->左->上->右
if (findWay3(map, i + 1, j)) { //先走下
return true;
} else if (findWay3(map, i, j - 1)) { //左
return true;
} else if (findWay3(map, i - 1, j)) { //上
return true;
} else if (findWay3(map, i, j + 1)) { //右
return true;
} else {
map[i][j] = 3;
return false;
}
} else { //map[i][j] = 1 , 2, 3
return false;
}
}
}
}
/*程序运行结果:
---------------------
=====当前地图情况======
1 1 1 1 1 1 1 1 1 1
1 0 0 0 0 0 0 0 0 1
1 0 0 0 1 1 0 0 0 1
1 1 1 1 1 0 0 0 0 1
1 0 0 0 0 0 1 0 0 1
1 0 0 0 0 1 1 1 1 1
1 0 0 0 1 1 0 0 0 1
1 0 0 0 1 0 0 0 0 1
1 0 0 0 0 0 0 0 0 1
1 1 1 1 1 1 1 1 1 1 ==第三种找路的情况如下==
1 1 1 1 1 1 1 1 1 1
1 2 0 2 2 2 2 3 3 1
1 2 2 2 1 1 2 3 3 1
1 1 1 1 1 2 2 3 3 1
1 0 0 0 2 2 1 3 3 1
1 0 0 2 2 1 1 1 1 1
1 0 0 2 1 1 0 0 0 1
1 0 0 2 1 0 0 0 0 1
1 0 0 2 2 2 2 2 2 1
1 1 1 1 1 1 1 1 1 1
--------------------*/

过程分析:

  分析如下图↓

Java笔记_递归回溯之小老鼠出迷宫问题的更多相关文章

  1. Java笔记_静态变量和实例变量的区别

    这里简单做一下笔记,区分Java全局变量里的静态变量与实例变量. 1.Java里的全局变量 首先了解Java里的全局变量,也叫成员变量. 特点: (1).一个类中既不在方法体内,也不在程序块内定义的变 ...

  2. [笔记] HOW2J.CN网站记录的java笔记_第四部分_HTML

    1.写一个显示Hello World的网页, <html> <body> <p>Hello World</p> </body> </h ...

  3. servlet(6) - servlet总结 - 小易Java笔记

    垂阅前必看: 这都是我总结的我觉得是学习servlet应该掌握的,我在学习期间也做了一个博客项目来让所学的知识得以巩固.下面就是博客项目链接.前面的servlet相关的笔记总汇,还有就是我把觉得在学习 ...

  4. 8皇后以及N皇后算法探究,回溯算法的JAVA实现,递归方案

    八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例.该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行.同 ...

  5. JSP(1) - JSP简介、原理、语法 - 小易Java笔记

    1.JSP简介 (1)JSP的全称是Java Server Pages(运行在服务器端的页面),实际就是Servlet(学习JSP的关键就是时刻联想到Servlet) (2)JSP.Servlet各自 ...

  6. Java与算法之(5) - 老鼠走迷宫(深度优先算法)

    小老鼠走进了格子迷宫,如何能绕过猫并以最短的路线吃到奶酪呢? 注意只能上下左右移动,不能斜着移动. 在解决迷宫问题上,深度优先算法的思路是沿着一条路一直走,遇到障碍或走出边界再返回尝试别的路径. 首先 ...

  7. java笔记整理

    Java 笔记整理 包含内容     Unix Java 基础, 数据库(Oracle jdbc Hibernate pl/sql), web, JSP, Struts, Ajax Spring, E ...

  8. Effective Java笔记一 创建和销毁对象

    Effective Java笔记一 创建和销毁对象 第1条 考虑用静态工厂方法代替构造器 第2条 遇到多个构造器参数时要考虑用构建器 第3条 用私有构造器或者枚举类型强化Singleton属性 第4条 ...

  9. React笔记_(3)_react语法2

    React笔记_(3)_react语法2 state和refs props就是在render渲染时,向组件内传递的变量,这个传递是单向的,只能继承下来读取. 如何进行双向传递呢? state (状态机 ...

  10. 算法基础_递归_求杨辉三角第m行第n个数字

    问题描述: 算法基础_递归_求杨辉三角第m行第n个数字(m,n都从0开始) 解题源代码(这里打印出的是杨辉三角某一层的所有数字,没用大数,所以有上限,这里只写基本逻辑,要符合题意的话,把循环去掉就好) ...

随机推荐

  1. Django框架之drf:5、反序列化器校验部分源码分析、断言、drf之请求与响应、视图组件介绍及两个视图基类、代码部分实战

    Django框架之drf 目录 Django框架之drf 一.反序列化类校验部分源码解析 二.断言 三.drf之请求 1.Request能够解析的前端传入编码格式 2.Request类中的属性和方法 ...

  2. Altium Designer v23.0.1.38图文详解

    Altium Designer (AD)  最新安装河蟹教程 ,ltium designer  显著地提高了用户体验和效率,利用时尚界面使设计流程流线化,同时实现了前所未有的性能优化.使用64位体系结 ...

  3. 一文看懂 Python 中的函数参数

    函数定义中的参数也就是形式参数,规定了在调用函数时如何传递实际参数以及这些参数有无默认值. 实参传递方式 def f(a): print(a) 实参传递方式有两种,位置和关键字.对于上面定义的函数 f ...

  4. 2.4.rpx单位有内置的视图容器组件

    所有的视图组件,包括view.swiper等,本身不显示任何可视化元素.它们的用途都是为了包裹其他真正显示的组件. # view 视图容器. 它类似于传统html中的div,用于包裹各种元素内容. 如 ...

  5. STM32F4库函数初始化系列:PWM输出

    1 void _TIM4_Configuration(void) 2 { 3 /* TIM4 Configuration --------------------------------------- ...

  6. js程序

    JavaScript 程序 计算机程序是由计算机"执行"的一系列"指令". 在编程语言中,这些编程指令被称为语句. JavaScript 程序就是一系列的编程语 ...

  7. The Missing Semester - 第二讲 学习笔记

    第二讲 Shell 工具和脚本 课程视频地址: https://www.bilibili.com/video/BV1Vv411v7FR 本机学习使用平台:虚拟机ubuntu18.04.6 主题一:Sh ...

  8. 下篇 | 使用 🤗 Transformers 进行概率时间序列预测

    在<使用 Transformers 进行概率时间序列预测>的第一部分里,我们为大家介绍了传统时间序列预测和基于 Transformers 的方法,也一步步准备好了训练所需的数据集并定义了环 ...

  9. 有趣的python库-pyttsx3

    pyttsx3-语音播报功能 基本使用: import pyttsx3 px = pyttsx3.init() px.say("hello world") px.runAndWai ...

  10. LG P4717 【模板】快速莫比乌斯/沃尔什变换 (FMT/FWT)

    \[C_k = \sum_{i|j=k}A_i B_j \] 这样的或卷积可以做一次 \(\text{FWT}\),把数组变为 \(\widehat{A}_i = \sum_{j\subseteq i ...