小老鼠走進了格子迷宮，如何能繞過貓並以最短的路線吃到奶酪呢？

註意只能上下左右移動，不能斜著移動。

在解決迷宮問題上，深度優先算法的思路是沿著一條路一直走，遇到障礙或走出邊界再返回嘗試別的路徑。

首先用一個二維數組來把迷宮“數字化”。

print?

1. int[][] maze = new int[5][4];

迷宮中每個格子的橫縱坐標對應數組的一維和二維索引，例如最左上角的格子是maze[0][0]，數組的值表示該格子是否可以通過，0表示可以通過，1表示該格子有貓。

初始化迷宮，標記貓的位置：

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。我們預先規定每到一個格子都按照右、下、左、上的順序嘗試下一個格子是否能走，如果右邊的格子沒有貓且未出邊界，就移動到下一個格子，繼續按照右、下、左、上的順序嘗試；如果右邊的格子不能走則嘗試下面的格子。

下面這個二維數組用來遍歷嘗試四個方向的格子：

print?

1. int[][] next = new int[][] {
2. {1, 0},
3. {0, 1},
4. {-1, 0},
5. {0, -1}
6. };

為了不走回頭路，我們還需要另外一個二維數組標記哪些格子是已走過的，如果已走過則不能回頭。

print?

1. int[][] mark = new int[5][4];

用一個棧記錄路徑

print?

1. LinkedList<Integer> map = new LinkedList<>();

走格子的思路是：

print?

1. for(遍歷四個方向的格子) {
2. if(格子超出邊界 或 格子有貓 或 格子已經走過) {
3. continue;
4. } else {
5. 移動到格子
6. 記錄當前格子已走過
7. 記錄當前路徑
8. for(以新格子為中心遍歷四個方向的格子) {
9. ......
10. }
11. }
12. }

但是我們並不知道要走多少步才能到達目標，也就不知道循環要嵌套多少層，但是可以看出每次新的遍歷循環開啟後，執行的代碼和上一層循環是一樣的，所以這裏用遞歸解決。來看完整的代碼：

print?

1. import java.util.LinkedList;
3. public class DfsRatMaze {
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<>();
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. }
54. /*
55. * 初始化迷宮
56. */
57. public void initMaze() {
58. this.maze = new int[width][height];
59. this.mark = new int[width][height];
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;
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. }
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. }

運行後輸出：

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與算法之(5) - 老鼠走迷宮(深度優先算法)