递归问题:一穿越迷宫

简介:

迷宫问题的解决涉及到大量的试探和失败:选择一条路径,在无法前景时折回,并选择其他还未尝试过的路径。使用递归能够很好的处理这类问题。


package com.chingcloud.test01;


public class Maze {
private final int TRIED = 3 ;
private final int PATH = 7 ;
private int[][] grid = {{1,1,1,0,1,1,0,0,0,1,1,1,1},
{1,0,1,1,1,0,1,1,1,1,0,0,1},
{0,0,0,0,1,0,1,0,1,0,1,0,0},
{1,1,1,0,1,1,1,0,1,0,1,1,1},
{1,0,1,0,0,0,0,1,1,1,0,0,1},
{1,0,1,1,1,1,1,1,0,1,1,1,1},
{1,0,0,0,0,0,0,0,0,0,0,0,0},
{1,1,1,1,1,1,1,1,1,1,1,1,1}} ;

public boolean traverse(int row,int column){
boolean done = false ;
if(valid(row,column)){
grid[row][column] = TRIED ;
if(row == grid.length-1 && column == grid[0].length-1){
done = true ;
}else{
done = traverse(row+1,column) ;
if(!done){
done = traverse(row,column+1) ;
}
if(!done){
done = traverse(row-1,column) ;
}
if(!done){
done = traverse(row,column-1) ;
}
}
if(done){
grid[row][column] = PATH ;
}
}
return done ;
}
public boolean valid(int row,int column){
boolean result = false ;
if(row>=0 && row<grid.length && column>=0 && column<grid[row].length){
if(grid[row][column]==1){
result = true ;
}
}
return result ;
}
public String toString(){
String result = "\n" ;
for(int row=0;row<grid.length;row++){
for(int column=0;column<grid[row].length;column++){
result += grid[row][column] + "" ;
}
result += "\n" ;
}
return result ;
}
public static void main(String[] args) {
Maze labyrinth = new Maze() ;
System.out.println(labyrinth);
if(labyrinth.traverse(0,0)){
System.out.println("The maze was successfully traversed!");
}else{
System.out.println("There is no possible path.");
}
System.out.println(labyrinth);
}
}


result



1110110001111
1011101111001
0000101010100
1110111010111
1010000111001
1011111101111
1000000000000
1111111111111


The maze was successfully traversed!


7770110001111
3077707771001
0000707070300
7770777070333
7070000773003
7077777703333
7000000000000
7777777777777

目录
相关文章
【动态规划】【树形dp】【深度优先搜索】LCP 26. 导航装置
【动态规划】【树形dp】【深度优先搜索】LCP 26. 导航装置
|
6月前
|
算法 定位技术 C++
基本算法-回溯法(迷宫问题)
基本算法-回溯法(迷宫问题)
164 0
|
18天前
|
传感器 算法 Serverless
迷宫穿越
迷宫穿越
12 1
|
9月前
1255:迷宫问题 2021-01-09
1255:迷宫问题 2021-01-09
|
9月前
1252:走迷宫 2021-01-05
1252:走迷宫 2021-01-05
|
6月前
|
算法 Python
使用深度优先搜索算法解决迷宫问题
迷宫问题是一个经典的算法问题,涉及到通过一个迷宫找到从起点到终点的路径。在本篇博客中,我们将探讨如何使用深度优先搜索(DFS)算法来解决迷宫问题。
199 2
|
9月前
|
机器学习/深度学习
1215:迷宫
1215:迷宫
|
存储 算法
407. 接雨水 II : 经典 Dijkstra 运用题
407. 接雨水 II : 经典 Dijkstra 运用题
|
存储
Leetcode-每日一题1210. 穿过迷宫的最少移动次数(BFS)
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/weixin_46618592/article/details/128890280?spm=1001.2014.3001.5501
87 0
Leetcode-每日一题1210. 穿过迷宫的最少移动次数(BFS)
迷宫最短路径问题
迷宫最短路径问题
206 0
迷宫最短路径问题