## 1. Problem

You are given an m x n grid where each cell can have one of three values:

- 0 representing an empty cell,
- 1 representing a fresh orange, or
- 2 representing a rotten orange.

Every minute, any fresh orange that is 4-directionally adjacent to a rotten orange becomes rotten.

Return the minimum number of minutes that must elapse until no cell has a fresh orange. If this is impossible, return -1.

**Example 1:**

```
Input: grid = [[2,1,1],[1,1,0],[0,1,1]]
Output: 4
```

**Example 2:**

```
Input: grid = [[2,1,1],[0,1,1],[1,0,1]]
Output: -1
Explanation: The orange in the bottom left corner (row 2, column 0) is never rotten, because rotting only happens 4-directionally.
```

**Example 3:**

```
Input: grid = [[0,2]]
Output: 0
Explanation: Since there are already no fresh oranges at minute 0, the answer is just 0.
```

**Constraints:**

- m == grid.length
- n == grid[i].length
- 1 <= m, n <= 10
- grid[i][j] is 0, 1, or 2.

## 2. Solution

I solved this problem like this.

- We can solve this problem to bfs. Using deque!

```
class Solution:
def orangesRotting(self, grid: List[List[int]]) -> int:
dr, dc = [-1, 0, 1, 0], [0, 1, 0, -1]
depth = 0
deq = deque()
for r in range(len(grid)):
for c in range(len(grid[r])):
if grid[r][c] == 2:
deq.append((r,c))
while deq:
now_nodes = deq.copy()
deq.clear()
for node in now_nodes:
r, c = node
for idx in range(4):
n_r, n_c = r + dr[idx], c + dc[idx]
if not (0 <= n_r <= len(grid)-1) or not (0 <= n_c <= len(grid[0])-1):
continue
if grid[n_r][n_c] == 2:
continue
if grid[n_r][n_c] == 1:
deq.append((n_r, n_c))
grid[n_r][n_c] = 2
continue
if not deq:
break
depth += 1
for r in range(len(grid)):
for c in range(len(grid[r])):
if grid[r][c] == 1:
return -1
return depth
```