小老鼠走进了格子迷宫，如何能绕过猫并以最短的路线吃到奶酪呢？
注意只能上下左右移动，不能斜着移动。
在解决迷宫问题上，深度优先算法的思路是沿着一条路一直走，遇到障碍或走出边界再返回尝试别的路径。
首先用一个二维数组来把迷宫“数字化”。
[java] view plain copy
1. int[][] maze = new int[5][4];迷宫中每个格子的横纵坐标对应数组的一维和二维索引，例如最左上角的格子是maze[0][0]，数组的值表示该格子是否可以通过，0表示可以通过，1表示该格子有猫。
初始化迷宫，标记猫的位置：
[java] view plain copy
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
1. int[][] next = new int[][] {
2. 1, 0},
3. 0, 1},
4. 1, 0},
5. 0, -1}
6. };为了不走回头路，我们还需要另外一个二维数组标记哪些格子是已走过的，如果已走过则不能回头。
[java] view plain copy
1. int[][] mark = new int[5][4];用一个栈记录路径
[java] view plain copy
1. LinkedList<Integer> map = new LinkedList<>();走格子的思路是：
[java] view plain copy
1. for(遍历四个方向的格子) {
2. if(格子超出边界 或 格子有猫 或 格子已经走过) {
3. continue;
4. else {
5. 移动到格子
6. 记录当前格子已走过
7. 记录当前路径
8. for(以新格子为中心遍历四个方向的格子) {
9. ......
10. }
11. }
12. }但是我们并不知道要走多少步才能到达目标，也就不知道循环要嵌套多少层，但是可以看出每次新的遍历循环开启后，执行的代码和上一层循环是一样的，所以这里用递归解决。来看完整的代码：
[java] view plain copy
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. 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. 1);
29. "[" + nextX + "," + nextY + "]");
30. if(i != 1)
31. "->");
32. }
33. System.out.println();
34. return;
35. }
36. for(posible = 0; posible < next.length; posible++) { //按右->下->左->上的顺序尝试
37. 0];
38. 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. 1;
46. 1); //递归调用, 移动到下一格
47. 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. "! ");
72. else if(this.maze[x][y] == 1) {
73. "* ");
74. else {
75. "_ ");
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. new DfsRatMaze();
87. d.initMaze();
88. 0);
89. if(d.min < Integer.MAX_VALUE)
90. "最少需要" + d.min + "步");
91. else
92. "目标地点无法到达");
93. }
94. }运行后输出：
[java] view plain copy
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行，真是神奇的算法。
