# Question

You are given a m x n 2D grid initialized with these three possible values.

- -1 - A wall or an obstacle.
- 0 - A gate.
- 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.

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

Do a breath-first search.

```
class Solution(object):
def wallsAndGates(self, rooms):
"""
:type rooms: List[List[int]]
:rtype: void Do not return anything, modify rooms in-place instead.
"""
if len(rooms) == 0 or len(rooms[0]) == 0:
return
currIndexes = list()
empty = set()
x, y = len(rooms), len(rooms[0])
for i in range(x):
for j in range(y):
if rooms[i][j] == 2147483647:
empty.add((i, j))
elif rooms[i][j] == 0:
currIndexes.append((i, j))
dist = 1
while len(empty) > 0:
if len(currIndexes) == 0:
break
curr = list()
for i, j in currIndexes:
self.process(i + 1, j, rooms, dist, empty, curr)
self.process(i - 1, j, rooms, dist, empty, curr)
self.process(i, j + 1, rooms, dist, empty, curr)
self.process(i, j - 1, rooms, dist, empty, curr)
dist += 1
currIndexes = curr
def process(self, i, j, rooms, dist, empty, curr):
if (i, j) in empty:
rooms[i][j] = dist
empty.remove((i, j))
curr.append((i, j))
```