墙与门

题目描述

你被给定一个 m × n 的二维网格 rooms ，网格中有以下三种可能的初始化值：

• -1 表示墙或是障碍物
• 0 表示一扇门
• INF 无限表示一个空的房间。然后，我们用 231 - 1 = 2147483647 代表 INF。你可以认为通往门的距离总是小于 2147483647 的。

你要给每个空房间位上填上该房间到 最近门的距离 ，如果无法到达门，则填 INF 即可。

示例一

输入：rooms = [[2147483647,-1,0,2147483647],[2147483647,2147483647,2147483647,-1],[2147483647,-1,2147483647,-1],[0,-1,2147483647,2147483647]]
输出：[[3,-1,0,1],[2,2,1,-1],[1,-1,2,-1],[0,-1,3,4]]

示例二

输入：rooms = [[-1]]
输出：[[-1]]

解题思路一_暴力法

• 暴力方法十分简单，我们只需要从每个空的房间开始做宽度优先搜索，找到最近的门即可。
• 我们搜索的时候，用一个二维的数组，记作 distance ，记录从起点出发的距离。它也能隐含一个位置是否已经被访问过的信息，以免被重复放入队列。

代码如下

class Solution {
    private static final int EMPTY = Integer.MAX_VALUE;
    private static final int GATE = 0;
    private static final int WALL = -1;
    private static final List<int[]> DIRECTIONS = Arrays.asList(
        new int[]{1, 0},
        new int[]{-1, 0},
        new int[]{0, 1},
        new int[]{0,-1}
    );
    public void wallsAndGates(int[][] rooms) {
        if(rooms.length == 0){
            return;
        }
        int m = rooms.length;
        int n = rooms[0].length;
        for(int i = 0; i < m; i ++){
            for(int j = 0; j < n; j ++){
                if(rooms[i][j] == EMPTY){
                    rooms[i][j] = distanceToNearestGate(rooms, i, j);
                }
            }
        }
    }
    private int distanceToNearestGate(int[][] rooms, int i, int j){
        int m = rooms.length;
        int n = rooms[0].length;
        int[][] distance = new int[m][n]; //每次宽度优先遍历都需要一个数组做辅助
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{i, j});
        while(!queue.isEmpty()){
            int[] point = queue.poll();
            int row = point[0];
            int col = point[1];
            for(int[] dir : DIRECTIONS){
                int x = row + dir[0];
                int y = col + dir[1];
                if(x < 0 || x >= m || y < 0 || y >= n || rooms[x][y] == WALL || distance[x][y] != 0){
                    continue;
                }
                distance[x][y] = distance[row][col] + 1;
                if(rooms[x][y] == GATE){
                    return distance[x][y];
                }
                queue.add(new int[]{x, y});
            }
        }
        return Integer.MAX_VALUE;
    }
}

• 时间复杂度：O(m^2n^2)，对 m×n 大小格子中的每一个点，门最远会在 m×n 步远的地方。
• 空间复杂度： O(mn)O(mn) 。空间复杂度取决于队列的大小。我们在从某个空房间开始搜索的时候，不会访问已经访问过的格子，所以队列里最多有m×n 个点。

解题思路二_宽度优先遍历

与其从一个空的房间开始找门，我们何不按另一种方式来搜索？换言之，我们从门开始做宽度优先搜索。由于宽度优先搜索保证我们在搜索 d + 1 距离的位置时， 距离为 d 的位置都已经被搜索过了，所以到达每一个房间的时候都一定是最短距离。

class Solution {
    private static final int EMPTY = Integer.MAX_VALUE;
    private static final int GATE = 0;
    private static final int WALL = -1;
    private static final List<int[]> DIRECTIONS = Arrays.asList(
        new int[]{1, 0},
        new int[]{-1, 0},
        new int[]{0, 1},
        new int[]{0,-1}
    );
    public void wallsAndGates(int[][] rooms) {
        if(rooms.length == 0){
            return;
        }
        int m = rooms.length;
        int n = rooms[0].length;
        Queue<int[]> queue = new LinkedList<>();
        for(int i = 0; i < m; i ++){
            for(int j = 0; j < n; j ++){
                if(rooms[i][j] == GATE){
                    queue.add(new int[]{i, j});
                }
            }
        }
        while(!queue.isEmpty()){
            int[] point = queue.poll();
            int row = point[0];
            int col = point[1];
            for(int[] dir : DIRECTIONS){
                int x = row + dir[0];
                int y = col + dir[1];
                if(x < 0 || x >= m || y < 0 || y >= n || rooms[x][y] != EMPTY){
                    continue;
                }
                rooms[x][y] = rooms[row][col] + 1;
                queue.add(new int[]{x, y});
            }
        }
    } 
}

• 时间复杂度： O(mn)
• 空间复杂度： O(mn)
• 空间复杂度与队列的大小有关。我们最多将 m×n 个位置插入队列，所以空间最大为 m×n 。