1926. 迷宫中离入口最近的出口

题目：

思路：

【1】利用广度搜索，相当于向四个方向各自分一个分身去走，碰到障碍物则该分身消失，然后每个分身到了下个位置再次分出四个走下一个位置，这样每一层的分身的步数其实是一致的，当有一个分身到了边界，那么这个位置就是最短的路径的出口。

代码展示：

//时间5 ms 击败 61.7%
//内存44.2 MB 击败 5.13%
class Solution {
    class Point {
        // 横坐标
        int x;
        // 纵坐标
        int y;
        // 步数
        int step;

        public Point(int x, int y, int step) {
            this.x = x;
            this.y = y;
            this.step = step;
        }
    }

    public int nearestExit(char[][] maze, int[] entrance) {
        return bfs(maze, entrance[0], entrance[1]);
    }

    public int bfs(char[][] maze, int i, int j) {
        //可以移动的方向
        int[] dx = {1, -1, 0, 0};
        int[] dy = {0, 0, 1, -1};
        int m = maze.length;
        int n = maze[0].length;
        Queue<Point> queue = new LinkedList<>();

        //入口入队
        queue.offer(new Point(i, j, 0));

        //标记为已访问过
        maze[i][j] = '+';
        while (!queue.isEmpty()) {
            Point poll = queue.poll();
            //不是入口，且是边界
            if (!(poll.x == i && poll.y == j) && (poll.x == 0 || poll.x == m - 1 || poll.y == 0 || poll.y == n - 1)) {
                return poll.step;
            }

            //枚举四个方向
            for (int k = 0; k < dx.length; k++) {
                int x = poll.x + dx[k];
                int y = poll.y + dy[k];

                //没越界且未访问过
                if (x >= 0 && x < m && y >= 0 && y < n && maze[x][y] == '.') {
                    queue.offer(new Point(x, y, poll.step + 1));
                    //标记为已访问过
                    maze[x][y] = '+';
                }
            }
        }
        //程序运行到这里，说明不存在这样的路径，返回 -1
        return -1;
    }
}