深度优先搜索DFS 走迷宫

要求：
1. 障碍物坐标处值为1，可走的为0.
2. 迷宫长宽小于50
3. 找到最短路径
4. 输出路径

深度优先的关键点
1. 函数的形式参数
2. 递归结束条件
3. 下一步的坐标计算
4. 判断是否下一步可走
5. 已走过的路做标记
6. 回溯时将当前步标记清除

分析：
1. 二维数组表示迷宫，参数需要当前坐标x,y，以及当前是第几步。
2. 结束条件为，找到目标。
3. 以顺时针方式计算下一步坐标，最多,有四种走法，右，下，左，上。用一个二维数组保存四种走法坐标的变化情况，next[4][2]={{1,0},{0,1},{-1,0},{0,-1}},遍历到一条路一直往前走，回溯时遍历下一条路。
4. 判断是否为障碍或者边界
5. 数组标记该坐标为2
6. 清除该坐标的标记

java实现如下

package aha_algorithm;

import java.util.Stack;

public class DFS_maze {
    int outX = 3, outY = 3;
    static int minStep = Integer.MAX_VALUE;
    int[][] next = new int[][]{{0, 1}, {1,0}, {0, -1}, {-1, 0}};
    private int right = 4;
    private int buttom = 5;
    Stack<String> pathTrace = new Stack<String>();
    int[][] maze = new int[][]{
            {0, 0, 1, 0}, 
            {0, 0, 0, 0}, 
            {0, 0, 1, 0}, 
            {0, 1, 0, 0}, 
            {0, 0, 0, 1}};
     static int[][] book = new int[5][4];//最好不要直接在maze中标记，不好调试。

//  boolean found = false;
    public static void main(String[] args) {
        book[0][0] =2;//初始将00点标记为开始点，不能重复走
        new DFS_maze().findBeauty(0, 0, 0);

        System.out.println("最小步数"+minStep);
    }

    void findBeauty(int currentX, int currentY, int step) {
        if (currentX == outX && currentY == outY) {

            System.out.println("当前步数"+step);
            //输出路径
            for (String item:pathTrace) {
                System.out.print(item+"->");
            }
            System.out.println();
            //输出maze图
            System.out.println("maze:");
            for (int i = 0; i < 5; i++) {
                for (int j = 0; j < 4; j++) {
                    System.out.print(maze[i][j]);
                }
                System.out.println();
            }
            //输出book图
            System.out.println("book路径:");
            for (int i = 0; i < 5; i++) {
                for (int j = 0; j < 4; j++) {
                    System.out.print(book[i][j]);
                }
                System.out.println();
            }
            System.out.println();

            if (step < minStep) {
                minStep = step;
            }


            return;//这里一定要注意返回
        }
        for (int i = 0; i < 4; i++) {
            int nextX = currentX + next[i][0];
            int nextY = currentY + next[i][1];

            if (nextX >= buttom || nextX < 0 || nextY >= right || nextY < 0 || maze[nextX][nextY] == 1 || book[nextX][nextY] == 2)
                continue;

            book[nextX][nextY] = 2;
            pathTrace.push(nextX+","+nextY);
//          System.out.print(nextX + "," + nextY+"-->");//显示路径的走向，这里从上一次路径递归返回时，循环确定下一步走法时开始输出，看结果book的路径更直观

            findBeauty(nextX, nextY, step + 1);
            book[nextX][nextY] = 0;//这里要清除标记   
            pathTrace.pop();
//          
        }
        return;
    }

}

结果：

当前步数6
0,1->1,1->1,2->1,3->2,3->3,3->
maze:
0010
0000
0010
0100
0001
book路径:
2200
0222
0002
0002
0000

当前步数10
0,1->1,1->2,1->2,0->3,0->4,0->4,1->4,2->3,2->3,3->
maze:
0010
0000
0010
0100
0001
book路径:
2200
0200
2200
2022
2220

当前步数10
0,1->1,1->1,0->2,0->3,0->4,0->4,1->4,2->3,2->3,3->
maze:
0010
0000
0010
0100
0001
book路径:
2200
2200
2000
2022
2220

当前步数6
1,0->1,1->1,2->1,3->2,3->3,3->
maze:
0010
0000
0010
0100
0001
book路径:
2000
2222
0002
0002
0000

当前步数10
1,0->1,1->2,1->2,0->3,0->4,0->4,1->4,2->3,2->3,3->
maze:
0010
0000
0010
0100
0001
book路径:
2000
2200
2200
2022
2220

当前步数8
1,0->2,0->2,1->1,1->1,2->1,3->2,3->3,3->
maze:
0010
0000
0010
0100
0001
book路径:
2000
2222
2202
0002
0000

当前步数8
1,0->2,0->3,0->4,0->4,1->4,2->3,2->3,3->
maze:
0010
0000
0010
0100
0001
book路径:
2000
2000
2000
2022
2220

最小步数6

虽然简单的程序，但是要调试出来直观的显示每一步怎么走的还是很有趣的！