Leetcode 286. Walls and Gates (Google面试题 BFS,记忆化搜索)

 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。1. 从门处搜。 2.可以首先把门节点先入队列，O（N*M）复杂度！！！

class Solution {
public:
    void wallsAndGates(vector<vector<int>>& rooms) {    //版本1
        int m=rooms.size();
        if(m==0) return ;
        int n=rooms[0].size();
        for(int i=0;i<m;i++) {
            for(int j=0;j<n;j++) {
                if(rooms[i][j]==0) {
                    bfs(i,j,rooms);
                }
            }
        }
    }
    struct node{
        int x,y;
        int dis;
    };
    void bfs(int sx,int sy,vector<vector<int>>& rooms) {
        int dir[][2]={-1,0,1,0,0,1,0,-1};
        int m=rooms.size(),n=rooms[0].size();
        queue<node> Queue;
        node start;
        start.x=sx,start.y=sy;start.dis=0;
        Queue.push(start);
        while(!Queue.empty()) {
            node cur=Queue.front();
            Queue.pop();
            node nex;
            for(int i=0;i<4;i++) {
                nex.x=cur.x+dir[i][0];
                nex.y=cur.y+dir[i][1];
                nex.dis=cur.dis+1;
                if(nex.x<0||nex.x>=m||nex.y<0||nex.y>=n||rooms[nex.x][nex.y]<=0||nex.dis>=rooms[nex.x][nex.y]) continue;
                rooms[nex.x][nex.y]=min(rooms[nex.x][nex.y],nex.dis);
                Queue.push(nex);
            }

        }
    }
};

class Solution {
public:
    void wallsAndGates(vector<vector<int>>& rooms) {    //版本2
        int m=rooms.size();
        if(m==0) return ;
        int n=rooms[0].size();
        queue<node> Queue;
        for(int i=0;i<m;i++) {
            for(int j=0;j<n;j++) {
                if(rooms[i][j]==0) {
                    node gate;
                    gate.x=i,gate.y=j;
                    gate.dis=0;
                    Queue.push(gate);
                }
            }
        }
        int dir[][2]={-1,0,1,0,0,1,0,-1};
        while(!Queue.empty()) {
            node cur=Queue.front();
            Queue.pop();
            node nex;
            for(int i=0;i<4;i++) {
                nex.x=cur.x+dir[i][0];
                nex.y=cur.y+dir[i][1];
                nex.dis=cur.dis+1;
                if(nex.x<0||nex.x>=m||nex.y<0||nex.y>=n||rooms[nex.x][nex.y]<=0||nex.dis>=rooms[nex.x][nex.y]) continue;
                rooms[nex.x][nex.y]=min(rooms[nex.x][nex.y],nex.dis);
                Queue.push(nex);
            }
            
        }
    }
    struct node{
        int x,y;
        int dis;
    };
};