490. The Maze

原题链接：https://leetcode.com/articles/the-maze/
这道题目是需要冲会员才能使用的，然而我个穷逼现在还是失业状态根本冲不起。。。以后如果把免费题目都刷完了的话，再来冲会员刷这些题目吧！

我的思路

迷宫类问题首先想到的就是回溯法了，思考+实现用了近 3 个小时，终于又写出了简单粗暴的实现来了：

import java.util.Stack;

/**
 * Created by clearbug on 2018/2/26.
 */
public class Solution {

    public static void main(String[] args) {
        Solution s = new Solution();
        /**
         * 0 0 1 0 0
         0 0 0 0 0
         0 0 0 1 0
         1 1 0 1 1
         0 0 0 0 0
         */
        int[][] board = {
                {0, 0, 1, 0, 0},
                {0, 0, 0, 0, 0},
                {0, 0, 0, 1, 0},
                {1, 1, 0, 1, 1},
                {0, 0, 0, 0, 0},
        };
        System.out.println(s.traverse(board, 0, 4, 4, 4));

        /**
         * 0 0 1 0 0
         0 0 0 0 0
         0 0 0 1 0
         1 1 0 1 1
         0 0 0 0 0

         */
        int[][] board2 = {
                {0, 0, 1, 0, 0},
                {0, 0, 0, 0, 0},
                {0, 0, 0, 1, 0},
                {1, 1, 0, 1, 1},
                {0, 0, 0, 0, 0},
        };
        System.out.println(s.traverse(board2, 0, 4, 3, 2));
    }

    public Stack<String> traverse(int[][] board, int rowStart, int colStart, int rowDest, int colDest) {
        board[rowStart][colStart] = -1; // 标记起始位置已来过

        Stack<String> res = new Stack<>();
        boolean dfsRes = dfs(board, rowStart, colStart, rowDest, colDest, res);
        System.out.println(dfsRes);
        return res;
    }

    public boolean dfs(int[][] board, int rowStart, int colStart, int rowDest, int colDest, Stack<String> res) {
        if (rowStart == rowDest && colStart == colDest) { // 说明已抵达目的地
            return true;
        }

        boolean exist = false;

        // up
        int upRow = rowStart - 1;
        while (upRow >= 0 && board[upRow][colStart] < 1) { // board[upRow][colStart] = 0 or board[upRow][colStart] = -1
            exist = true;
            upRow--;
        }
        if (exist) {
            upRow++;
            res.push("up");
            if (upRow == rowDest && colStart == colDest) { // 说明已抵达目的地
                return true;
            }
            if (board[upRow][colStart] == -1) { // 说明来过这个位置，目前又循环回来了，所以是死路
                res.pop();
            } else {
                board[upRow][colStart] = -1; // 标记这个位置已来过
                if (dfs(board, upRow, colStart, rowDest, colDest, res)) {
                    return true;
                } else {
                    res.pop();
                }
            }
        }


        exist = false;
        // down
        int downRow = rowStart + 1;
        while (downRow < board.length && board[downRow][colStart] < 1) { // board[downRow][colStart] = 0 or board[downRow][colStart] = -1
            exist = true;
            downRow++;
        }
        if (exist) {
            downRow--;
            res.push("down");
            if (downRow == rowDest && colStart == colDest) { // 说明已抵达目的地
                return true;
            }
            if (board[downRow][colStart] == -1) { // 说明来过这个位置，目前又循环回来了，所以是死路
                res.pop();
            } else {
                board[downRow][colStart] = -1; // 标记这个位置已来过
                if (dfs(board, downRow, colStart, rowDest, colDest, res)) {
                    return true;
                } else {
                    res.pop();
                }
            }
        }

        exist = false;
        // left
        int leftCol = colStart - 1;
        while (leftCol >= 0 && board[rowStart][leftCol] < 1) {
            exist = true;
            leftCol--;
        }
        if (exist) {
            leftCol++;
            res.push("left");
            if (rowStart == rowDest && leftCol == colDest) {
                return true;
            }
            if (board[rowStart][leftCol] == -1) {
                res.pop();
            } else {
                board[rowStart][leftCol] = -1;
                if (dfs(board, rowStart, leftCol, rowDest, colDest, res)) {
                    return true;
                } else {
                    res.pop();
                }
            }
        }

        exist = false;
        // right
        int rightCol = colStart + 1;
        while (rightCol < board[rowStart].length && board[rowStart][rightCol] < 1) {
            exist = true;
            rightCol++;
        }
        if (exist) {
            rightCol--;
            res.push("right");
            if (rowStart == rowDest && rightCol == colDest) {
                return true;
            }
            if (board[rowStart][rightCol] == -1) {
                res.pop();
            } else {
                board[rowStart][rightCol] = -1;
                if (dfs(board, rowStart, rightCol, rowDest, colDest, res)) {
                    return true;
                } else {
                    res.pop();
                }
            }
        }

        return false;
    }


}

当然了，可以使用类似骑士游历问题中的预测算法来提高效率。下面就来看看官方解答是怎么的吧！

官方方法一（深入优先搜索）

深度优先搜索，英文全称为 Depth First Search，简称为 DFS。毫无疑问，跟我的思路是一样的，就是代码更加简洁，所以我的解法其实就是深度优先搜索啦！

官方解法二（广度优先搜索）

广度优先搜索，英文全称 Breadth First Search，简称 BFS。不过我思考了下，这种广度优先搜索算法最终是无法求出小球所走过的路径的，只能判断小球最终是否会到达目的地。还是按照惯例抄袭一遍代码就当学会了吧：

import java.util.LinkedList;
import java.util.Stack;
import java.util.Queue;

/**
 * Created by clearbug on 2018/2/26.
 */
public class Solution {

    public static void main(String[] args) {
        Solution s = new Solution();
        /**
         * 0 0 1 0 0
         0 0 0 0 0
         0 0 0 1 0
         1 1 0 1 1
         0 0 0 0 0
         */
        int[][] board = {
                {0, 0, 1, 0, 0},
                {0, 0, 0, 0, 0},
                {0, 0, 0, 1, 0},
                {1, 1, 0, 1, 1},
                {0, 0, 0, 0, 0},
        };
        System.out.println(s.hasPath(board, new int[]{0, 4}, new int[]{4, 4}));

        /**
         * 0 0 1 0 0
         0 0 0 0 0
         0 0 0 1 0
         1 1 0 1 1
         0 0 0 0 0

         */
        int[][] board2 = {
                {0, 0, 1, 0, 0},
                {0, 0, 0, 0, 0},
                {0, 0, 0, 1, 0},
                {1, 1, 0, 1, 1},
                {0, 0, 0, 0, 0},
        };
        System.out.println(s.hasPath(board2, new int[]{0, 4}, new int[]{3, 2}));
    }

    public boolean hasPath(int[][] maze, int[] start, int[] dest) {
        boolean[][] visited = new boolean[maze.length][maze[0].length];
        visited[start[0]][start[1]] = true;

        int[][] dirs = {
                {0, 1},
                {0, -1},
                {-1, 0},
                {1, 0}
        };

        Queue<int[]> queue = new LinkedList<>();
        queue.add(start);

        while (!queue.isEmpty()) {
            int[] s = queue.remove();
            if (s[0] == dest[0] && s[1] == dest[1]) {
                return true;
            }
            for (int[] dir : dirs) {
                int x = s[0] + dir[0];
                int y = s[1] + dir[1];
                while (x >= 0 && y >= 0 && x < maze.length && y < maze[0].length && maze[x][y] == 0) {
                    x += dir[0];
                    y += dir[1];
                }
                if (!visited[x - dir[0]][y - dir[1]]) {
                    queue.add(new int[]{x - dir[0], y - dir[1]});
                    visited[x - dir[0]][y - dir[1]] = true;
                }
            }
        }

        return false;
    }

}