Java数据结构之回溯算法的递归应用迷宫的路径问题

  1 /**
  2  * 回溯法解决，迷宫算法
  3  * 
  4  * @author MIX
  5  * 
  6  */
  7 public class MyMaze {
  8 
  9     private static int startPosI; // 入口的i下标
 10     private static int startPosJ; // 入口的j下标
 11     private static int endPosI; // 出口的j下标
 12     private static int endPosJ; // 出口的j下标
 13 
 14     // 设置迷宫入口的坐标
 15     public void setStart(int startPosI, int startPosJ) {
 16 
 17         MyMaze.startPosI = startPosI;
 18         MyMaze.startPosJ = startPosJ;
 19     }
 20 
 21     // 设置迷宫出口的坐标
 22     public void setEnd(int endPosI, int endPosJ) {
 23 
 24         MyMaze.endPosI = endPosI;
 25         MyMaze.endPosJ = endPosJ;
 26     }
 27 
 28     // 迷宫搜索通路的算法
 29     /**
 30      * 
 31      * @param cell
 32      *            迷宫地图
 33      * @param i
 34      *            入口的i坐标
 35      * @param j
 36      *            入口的j坐标
 37      */
 38     public static void visited(int[][] cell, int i, int j) {
 39         // 表示此路为通
 40         /*
 41          * 该标记记为走过该路径，一旦该路径为通路且走到了该路径那么就将该位置置为1
 42          */
 43         cell[i][j] = 1;
 44         String oriention = null;
 45         if (i == endPosI && j == endPosJ) { // 找到了出口
 46             System.out.println("找到一条通路");
 47             for (int m = 0; m < cell.length; m++) {
 48                 for (int n = 0; n < cell[i].length; n++) {
 49                     if (cell[m][n] == 2) {
 50                         System.out.print("2");
 51                     } else if (cell[m][n] == 1) {
 52                         System.out.print("*");
 53                     } else {
 54                         System.out.print(" ");
 55                     }
 56                 }
 57                 System.out.println();
 58             }
 59         }
 60 
 61         // 向左边寻找通路
 62         if (cell[i][j - 1] == 0) {
 63             oriention = "left";
 64             visited(cell, i, j - 1);
 65         }
 66         // 向右寻找通路
 67         if (cell[i][j + 1] == 0) {
 68             oriention = "right";
 69             visited(cell, i, j + 1);
 70         }
 71         // 向上寻找通路
 72         if (cell[i - 1][j] == 0) {
 73             oriention = "up";
 74             visited(cell, i - 1, j);
 75         }
 76         // 向下寻找通路
 77         if (cell[i + 1][j] == 0) {
 78             oriention = "down";
 79             visited(cell, i + 1, j);
 80         }
 81         /*
 82          * 一旦该路径走到了死胡同里，清理走过的路径将当前位置重新标志为1，推出当前递归的迭代堆栈，返回上一次，继续
 83          * 在当前函数里面的应用主要是清理之前走过的但是被标记为1的位置，将该位置重新置为0，以便下一次的位置可以访问
 84          */
 85         oriention = "无知的我";
 86         cell[i][j] = 0;
 87 
 88     }
 89 
 90     public static void main(String[] args) {
 91         // 初始化一个迷宫地图
 92         int[][] maze = { { 2, 2, 2, 2, 2, 2, 2, 2, 2 },
 93                 { 2, 0, 0, 0, 0, 0, 0, 0, 2 }, { 2, 0, 2, 2, 0, 2, 2, 0, 2 },
 94                 { 2, 0, 2, 0, 0, 2, 0, 0, 2 }, { 2, 0, 2, 0, 2, 0, 2, 0, 2 },
 95                 { 2, 0, 0, 0, 0, 0, 2, 0, 2 }, { 2, 2, 0, 2, 2, 0, 2, 2, 2 },
 96                 { 2, 0, 0, 0, 0, 0, 0, 0, 2 }, { 2, 2, 2, 2, 2, 2, 2, 2, 2 } };
 97 
 98         // MyMaze cell = new MyMaze();
 99         // cell.setStart(1, 1);
100         // cell.setEnd(7, 7);
101         // cell.visited(maze, startPosI, startPosI);
102         int[][] maze2 = { { 2, 2, 2, 2 }, { 2, 0, 0, 2 }, { 2, 0, 0, 2 },
103                 { 2, 2, 2, 2 } };
104         MyMaze cell = new MyMaze();
105         cell.setStart(1, 1);
106         cell.setEnd(2, 2);
107         cell.visited(maze2, startPosI, startPosJ);
108     }
109 
110 }