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

For example, given the 2D grid:

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

class Solution {
public:
    void wallsAndGates(vector<vector<int>>& rooms) {
        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);
            }
    }
private:
    void bfs(int i,int j,vector<vector<int>>& rooms)
    {
        int m = rooms.size();
        
 
int n = rooms[0].size();
        vector<vector<int>> visited(m,vector<int>(n,false));
        visited[i][j] = true;
        queue<pair<int,int>> q;
        vector<pair<int,int>> dirs = {{-1,0},{1,0},{0,-1},{0,1}};
        q.push({i,j});
        int step = 0;
        while(!q.empty())
        {
            int N = q.size();
            step++;
            for(int i = 0;i<N;i++)
            {
                int r = q.front().first;
                int c = q.front().second;
                q.pop();
              
                for(auto dir:dirs)
                {
                    int nextr = r+dir.first;
                    int nextc = c+dir.second;
                    if(nextr<0 || nextr>=m || nextc<0 || nextc>=n || rooms[nextr][nextc] <=0 || visited[nextr][nextc]) continue;
                    visited[nextr][nextc] = true;
                    q.push({nextr,nextc}); 
                    rooms[nextr][nextc]= min(rooms[nextr][nextc],step);
                }  
            }
        } 
    }
};

286. Walls and Gates