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

Posted 撒_旦

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java与算法之 - 老鼠走迷宫(深度优先算法)相关的知识,希望对你有一定的参考价值。

小老鼠走进了格子迷宫,如何能绕过猫并以最短的路线吃到奶酪呢?

注意只能上下左右移动,不能斜着移动。

技术分享

在解决迷宫问题上,深度优先算法的思路是沿着一条路一直走,遇到障碍或走出边界再返回尝试别的路径。

首先用一个二维数组来把迷宫“数字化”。

技术分享

 

[java] view plain copy
 
 print?技术分享技术分享
  1. int[][] maze = new int[5][4];  

迷宫中每个格子的横纵坐标对应数组的一维和二维索引,例如最左上角的格子是maze[0][0],数组的值表示该格子是否可以通过,0表示可以通过,1表示该格子有猫。

 

初始化迷宫,标记猫的位置:

 

[java] view plain copy
 
 print?技术分享技术分享
  1. this.maze[2][0] = 1;  
  2. this.maze[1][2] = 1;  
  3. this.maze[2][2] = 1;  
  4. this.maze[3][2] = 1;  

起点位置坐标是x=0,y=0,如果向右移动就是x=x+1,y=y,向下移动是x=x,y=y+1。我们预先规定每到一个格子都按照右、下、左、上的顺序尝试下一个格子是否能走,如果右边的格子没有猫且未出边界,就移动到下一个格子,继续按照右、下、左、上的顺序尝试;如果右边的格子不能走则尝试下面的格子。

 

下面这个二维数组用来遍历尝试四个方向的格子:

 

[java] view plain copy
 
 print?技术分享技术分享
  1. int[][] next = new int[][] {  
  2.         {1, 0},  
  3.         {0, 1},  
  4.         {-1, 0},  
  5.         {0, -1}  
  6. };  

为了不走回头路,我们还需要另外一个二维数组标记哪些格子是已走过的,如果已走过则不能回头。

 

 

[java] view plain copy
 
 print?技术分享技术分享
  1. int[][] mark = new int[5][4];  

用一个栈记录路径

 

 

[java] view plain copy
 
 print?技术分享技术分享
  1. LinkedList<Integer> map = new LinkedList<>();  

走格子的思路是:

 

 

[java] view plain copy
 
 print?技术分享技术分享
  1. for(遍历四个方向的格子) {  
  2.     if(格子超出边界 或 格子有猫 或 格子已经走过) {  
  3.         continue;  
  4.     } else {  
  5.     移动到格子  
  6.     记录当前格子已走过  
  7.     记录当前路径  
  8.     for(以新格子为中心遍历四个方向的格子) {  
  9.         ......  
  10.     }  
  11.     }  
  12. }  

但是我们并不知道要走多少步才能到达目标,也就不知道循环要嵌套多少层,但是可以看出每次新的遍历循环开启后,执行的代码和上一层循环是一样的,所以这里用递归解决。来看完整的代码:

 

 

[java] view plain copy
 
 print?技术分享技术分享
  1. import java.util.LinkedList;  
  2.   
  3. public class DfsRatMaze {  
  4.   
  5.     int min = Integer.MAX_VALUE;  
  6.     int endX = 3;  //目标点横坐标  
  7.     int endY = 3;  //目标点纵坐标  
  8.     int width = 5;  //迷宫宽度  
  9.     int height = 4;  //迷宫高度  
  10.     int[][] maze = new int[5][4];  
  11.     int[][] mark = new int[5][4];  
  12.     LinkedList<Integer> map = new LinkedList<>();  
  13.   
  14.     public void dfs(int startX, int startY, int step) {  
  15.         int[][] next = new int[][] { //按右->下->左->上的顺序尝试  
  16.                 {1, 0},  
  17.                 {0, 1},  
  18.                 {-1, 0},  
  19.                 {0, -1}  
  20.         };  
  21.         int nextX, nextY;  
  22.         int posible;  
  23.         if(startX == endX && startY == endY) {  
  24.             if(step < min)  
  25.                 min = step;  
  26.             for(int i = map.size() - 1; i >= 0; i -= 2){  
  27.                 nextX = map.get(i);  
  28.                 nextY = map.get(i - 1);  
  29.                 System.out.print("[" + nextX + "," + nextY + "]");  
  30.                 if(i != 1)  
  31.                     System.out.print("->");  
  32.             }  
  33.             System.out.println();  
  34.             return;  
  35.         }  
  36.         for(posible = 0; posible < next.length; posible++) { //按右->下->左->上的顺序尝试  
  37.             nextX = startX + next[posible][0];  
  38.             nextY = startY + next[posible][1];  
  39.             if(nextX < 0 || nextX >= width || nextY < 0 || nextY >= height) {  //超出边界  
  40.                 continue;  
  41.             }  
  42.             if(maze[nextX][nextY] == 0 && mark[nextX][nextY] == 0) {  //非障碍且未标记走过  
  43.                 map.push(nextX);  
  44.                 map.push(nextY);  
  45.                 mark[nextX][nextY] = 1;  
  46.                 dfs(nextX, nextY, step + 1);  //递归调用, 移动到下一格  
  47.                 mark[nextX][nextY] = 0;  
  48.                 map.pop();  
  49.                 map.pop();  
  50.             }  
  51.         }  
  52.     }  
  53.   
  54.     /* 
  55.      * 初始化迷宫 
  56.      */  
  57.     public void initMaze() {  
  58.         this.maze = new int[width][height];  
  59.         this.mark = new int[width][height];  
  60.   
  61.         this.maze[2][0] = 1;  
  62.         this.maze[1][2] = 1;  
  63.         this.maze[2][2] = 1;  
  64.         this.maze[3][2] = 1;  
  65.         this.mark[0][0] = 1;  
  66.   
  67.         //打印迷宫 _表示可通行 *表示障碍 !表示目标  
  68.         for(int y = 0; y < height; y++) {  
  69.             for(int x = 0; x < width; x++) {  
  70.                 if(x == endX && y == endY) {  
  71.                     System.out.print("!  ");  
  72.                 }  else if(this.maze[x][y] == 1) {  
  73.                     System.out.print("*  ");  
  74.                 } else {  
  75.                     System.out.print("_  ");  
  76.                 }  
  77.             }  
  78.             System.out.println();  
  79.         }  
  80.         System.out.println();  
  81.     }  
  82.   
  83.     public static void main(String[] args) {  
  84.         int startX = 0;  
  85.         int startY = 0;  
  86.         DfsRatMaze d = new DfsRatMaze();  
  87.         d.initMaze();  
  88.         d.dfs(startX, startY, 0);  
  89.         if(d.min < Integer.MAX_VALUE)  
  90.             System.out.println("最少需要" + d.min + "步");  
  91.         else  
  92.             System.out.println("目标地点无法到达");  
  93.     }  
  94. }  

运行后输出:

 

[java] view plain copy
 
 print?技术分享技术分享
  1. [1,0]->[1,1]->[2,1]->[3,1]->[4,1]->[4,2]->[4,3]->[3,3]  
  2. [1,0]->[1,1]->[2,1]->[3,1]->[3,0]->[4,0]->[4,1]->[4,2]->[4,3]->[3,3]  
  3. [1,0]->[1,1]->[0,1]->[0,2]->[0,3]->[1,3]->[2,3]->[3,3]  
  4. [0,1]->[1,1]->[2,1]->[3,1]->[4,1]->[4,2]->[4,3]->[3,3]  
  5. [0,1]->[1,1]->[2,1]->[3,1]->[3,0]->[4,0]->[4,1]->[4,2]->[4,3]->[3,3]  
  6. [0,1]->[0,2]->[0,3]->[1,3]->[2,3]->[3,3]  
  7. 最少需要6步  

可以看到,程序计算出了所有路线,并找到了最短的路线。而整个代码还不到100行,真是神奇的算法。

以上是关于Java与算法之 - 老鼠走迷宫(深度优先算法)的主要内容,如果未能解决你的问题,请参考以下文章

跟耿老师学Java:贪心算法与老鼠走迷宫

[算法与数据结构] 走迷宫问题(广度与深度优先搜索)

贪心算法与老鼠走迷宫

算法浅谈——走迷宫问题与广度优先搜索

自动走迷宫--深度优先(非递归)算法

数据结构与算法-深度优先搜索