[leetcode] 286. Walls and Gates 解题报告

题目链接：https://leetcode.com/problems/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

思路：BFS和DFS都可以解决. 不过DFS要比BFS清晰简洁很多.

代码如下：

DFS

class Solution {
public:
    void DFS(vector<vector<int>>& rooms, int x, int y, int dis)
    {
        int row = rooms.size(), col = rooms[0].size();
        if(x<0||y<0||x>=row||y>=col||rooms[x][y]<0||rooms[x][y]<dis) return;
        rooms[x][y] = dis++;
        DFS(rooms, x+1, y, dis);
        DFS(rooms, x-1, y, dis);
        DFS(rooms, x, y+1, dis);
        DFS(rooms, x, y-1, dis);
    }
    
    void wallsAndGates(vector<vector<int>>& rooms) {
        if(rooms.size()==0) return;
        int row = rooms.size(), col = rooms[0].size();
        for(int i = 0; i < row; i++)
        {
            for(int j = 0; j < col; j++)
                if(rooms[i][j] == 0) DFS(rooms, i, j, 0);
        }
    }
};

BFS

class Solution {
public:
    void wallsAndGates(vector<vector<int>>& rooms) {
        if(rooms.size()==0) return;
        int row = rooms.size(), col = rooms[0].size();
        for(int i = 0; i < row; i++)
        {
            for(int j =0; j < col; j++)
            {
                if(rooms[i][j] != 0) continue;
                queue<pair<int, int>> que;
                que.push(make_pair(i*col+j, 0));
                while(!que.empty())
                {
                    auto val = que.front();
                    que.pop();
                    int x = val.first/col, y = val.first%col;
                    if(x-1 >= 0 && rooms[x-1][y] > val.second+1)
                    {
                        rooms[x-1][y] = val.second+1;
                        que.push(make_pair((x-1)*col+y, val.second+1));
                    }
                    if(x+1 < row && rooms[x+1][y] > val.second+1)
                    {
                        rooms[x+1][y] = val.second+1;
                        que.push(make_pair((x+1)*col+y, val.second+1));
                    }
                    if(y-1>=0 && rooms[x][y-1] > val.second+1)
                    {
                        rooms[x][y-1] = val.second+1;
                        que.push(make_pair(x*col+y-1, val.second+1));
                    }
                    if(y+1 < col && rooms[x][y+1] > val.second+1)
                    {
                        rooms[x][y+1] = val.second+1;
                        que.push(make_pair(x*col+y+1, val.second+1));
                    }
                }
            }
        }
    }
};