Walls and Gates

You are given a m x n 2D grid initialized with these three possible values.

1. -1 - A wall or an obstacle.
2. 0 - A gate.
3. INF - Infinity means an empty room. We use the value 231 - 1 = 2147483647 to represent INF as you may assume that the distance to a gate is less than 2147483647.

Fill each empty room with the distance to its nearest gate. If it is impossible to reach a gate, it should be filled with INF.

For example, given the 2D grid:

INF  -1  0  INF
INF INF INF  -1
INF  -1 INF  -1
  0  -1 INF INF

After running your function, the 2D grid should be:

  3  -1   0   1
  2   2   1  -1
  1  -1   2  -1
  0  -1   3   4

思路：算法，从gate (0) 开始往外走，一层一层的走；BFS level 扩展；先收集所有0的点，然后一步一步同时往外面扩展，扩展的时候判断 !visited && != -1 && == Integer.MAX_VALUE; T: O(m*n) S:O(m*n)

class Solution {
    public void wallsAndGates(int[][] rooms) {
        int m = rooms.length;
        int n = rooms[0].length;
        Queue<int[]> queue = new LinkedList<>();
        boolean[][] visited = new boolean[m][n];
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(rooms[i][j] == 0) {
                    queue.offer(new int[]{i, j});
                    visited[i][j] = true;
                }
            }
        }
        
        int[][] dirs = {{0,1},{0,-1},{-1,0},{1,0}};
        int step = 1;
        while(!queue.isEmpty()) {
            int size = queue.size();
            for(int i = 0; i < size; i++) {
                int[] node = queue.poll();
                for(int[] dir: dirs) {
                    int nx = node[0] + dir[0];
                    int ny = node[1] + dir[1];
                    if(0 <= nx && nx < m && 0 <= ny && ny < n 
                       && rooms[nx][ny] == Integer.MAX_VALUE && !visited[nx][ny]) {
                        rooms[nx][ny] = step;
                        visited[nx][ny] = true;
                        queue.offer(new int[]{nx, ny});
                    }
                }
            }
            step++;
        }
    }
}