994. 腐烂的橘子

题目：
在给定的 m x n 网格 grid 中，每个单元格可以有以下三个值之一：

• 值 0 代表空单元格；
• 值 1 代表新鲜橘子；
• 值 2 代表腐烂的橘子。

每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

返回 直到单元格中没有新鲜橘子为止所必须经过的最小分钟数。如果不可能，返回 -1 。

算法：
方法一：多源BFS

func orangesRotting(grid [][]int) int {
    good, cost := 0, 0
    n, m := len(grid), len(grid[0])
    // 腐烂的橘子加入queue
    queue := make([][]int, 0)
    for i := 0; i < n; i ++ {
        for j := 0; j < m; j ++ {
            if grid[i][j] == 1 {
                good ++
            } else if grid[i][j] == 2 {
                queue = append(queue, []int{i, j})
            }
        }
    }
    direction := [][]int{[]int{-1, 0},[]int{1, 0},[]int{0, 1},[]int{0, -1}}
    // queue中还有腐烂的句子，并且还有新鲜的橘子，则继续BFS，否则退出
    for len(queue) != 0 && good > 0 {
        cost ++
        length := len(queue)
        for i := 0; i < length; i ++ {
            // 腐烂的橘子感染周围新鲜的橘子
            for _, dir := range direction {
                x, y := queue[i][0] + dir[0], queue[i][1] + dir[1]
                if 0 <= x && x < n && 0 <= y && y < m {
                    // 将新被感染的橘子加入queue，进行下一次BFS遍历
                    if grid[x][y] == 1 {
                        good --
                        grid[x][y] = 2
                        queue = append(queue, []int{x, y})
                    }
                }
            }
        }
        queue = queue[length:]
    }
    if good == 0 {
        return cost
    }
    return -1
}