Walls and Gates 解答

Question

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 than2147483647.

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

Solution

Problems like "shortest distance/ nearest neighbor" can be always solved by BFS.

distance from a specific point (x, y) to one exit (x', y') = distance from (x', y') to (x, y)

So we start BFS on exit points.

Af first, I tried BFS on every exit point one by one, but the time consuming is huge and reports "Time Limit Exceed".

One key point is that we can add all exit points at first, and do BFS once. Time complexity O(mn).

For BFS, don't forget visited[][] array.

 public class Solution {
     private final int[][] directions = {{0,1},{0,-1},{1,0},{-1,0}};

     public void wallsAndGates(int[][] rooms) {
         if (rooms == null || rooms.length < 1) {
             return;
         }
         int m = rooms.length, n = rooms[0].length;
         int distance = 0;
         Deque<int[]> queue = new LinkedList<int[]>();
         boolean[][] visited = new boolean[m][n];
         // Add all exit points to queue
         for (int i = 0; i < m; i++) {
             for (int j = 0; j < n; j++) {
                 if (rooms[i][j] == 0) {
                     queue.add(new int[]{i, j});
                 }
             }
         }
         // BFS
         while (!queue.isEmpty()) {
             distance++;
             int size = queue.size();
             for (int i = 0; i < size; i++) {
                 int[] prev = queue.poll();
                 for (int k = 0; k < 4; k++) {
                     int newX = prev[0] + directions[k][0];
                     int newY = prev[1] + directions[k][1];
                     if (newX < 0 || newX >= rooms.length || newY < 0 || newY >= rooms[0].length) {
                         continue;
                     }
                     if (rooms[newX][newY] == -1) {
                         continue;
                     }
                     // !!! check visisted
                     if (visited[newX][newY]) {
                         continue;
                     }
                     visited[newX][newY] = true;
                     if (rooms[newX][newY] > distance) {
                         rooms[newX][newY] = distance;
                     }
                     queue.offer(new int[]{newX, newY});
                 }
             }
         }
     }
 }