[LeetCode] Walls and Gates

Problem Description:

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

---

An application of BFS. The key is to apply appropriate pruning. This post shares a very clear solution in Python, which is rewritten in C++ as follows.

class Solution {
public:
    void wallsAndGates(vector<vector<int>>& rooms) {
        if (rooms.empty()) return;
        int m = rooms.size(), n = rooms[0].size();
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (!rooms[i][j]) {
                    queue<Grid> grids;
                    grids.push(Grid(i + 1, j, 1));
                    grids.push(Grid(i - 1, j, 1));
                    grids.push(Grid(i, j + 1, 1));
                    grids.push(Grid(i, j - 1, 1));
                    while (!grids.empty()) {
                        Grid grid = grids.front();
                        grids.pop();
                        int r = grid.r, c = grid.c, d = grid.d;
                        if (r < 0 || r >= m || c < 0 || c >= n || rooms[r][c] < d)
                            continue;
                        rooms[r][c] = d;
                        grids.push(Grid(r + 1, c, d + 1));
                        grids.push(Grid(r - 1, c, d + 1));
                        grids.push(Grid(r, c + 1, d + 1));
                        grids.push(Grid(r, c - 1, d + 1));
                    }
                }
            }
        }
    }
private:
    struct Grid {
        int r, c, d;
        Grid(int _r, int _c, int _d) : r(_r), c(_c), d(_d) {}
    };
};

Stefan posts a nice C++ solution using #define helper functions here, which is rewritten below using private functions.

class Solution {
public:
    void wallsAndGates(vector<vector<int>>& rooms) {
        int m = rooms.size(), n = m ? rooms[0].size() : 0;
        queue<pair<int, int>> q;
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                if (!rooms[i][j]) q.push({i, j});
        for (int d = 1; !q.empty(); d++) {
            for (int k = q.size(); k; k--) {
                int i = q.front().first, j = q.front().second;
                q.pop();
                add(rooms, q, i - 1, j, m, n, d);
                add(rooms, q, i + 1, j, m, n, d);
                add(rooms, q, i, j - 1, m, n, d);
                add(rooms, q, i, j + 1, m, n, d); 
            }
        }
    }
private:
    void add(vector<vector<int>>& rooms, queue<pair<int, int>>& q, int i, int j, int m, int n, int d) {
        if (i >= 0 && i < m && j >= 0 && j < n && rooms[i][j] > d) {
            q.push({i, j});
            rooms[i][j] = d;
        }
    }
};

RileCurry_adorable has suggested the following solution, which I find more concise :-) 

class Solution {
public:
    void wallsAndGates(vector<vector<int>>& rooms) {
        if (rooms.empty()) return;
        int m = rooms.size(), n = rooms[0].size();
        queue<pair<int, int>> q;
        vector<pair<int, int>> dirs = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
        for (int i = 0; i < m; i++)
            for (int j = 0; j < n; j++)
                if (!rooms[i][j])
                    q.push(make_pair(i, j));
        while (!q.empty()) {
            int r = q.front().first, c = q.front().second;
            q.pop();
            for (auto dir : dirs) {
                int x = r + dir.first, y = c + dir.second;
                if (x < 0 || y < 0 || x >= m || y >= n || rooms[x][y] <= rooms[r][c] + 1)
                    continue;
                rooms[x][y] = rooms[r][c] + 1;
                q.push(make_pair(x, y));
            }
        }
    }
};