题目：

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

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

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

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

方法：

代码：

class Solution {
    public int orangesRotting(int[][] grid) {
        int M = grid.length;
        int N = grid[0].length;
        Queue<int[]> queue = new LinkedList<>();

        int count = 0;
        for (int m = 0; m < M; m++) {
            for (int n = 0; n < N; n++) {
                if (grid[m][n] == 1)
                    count++;
                else if (grid[m][n] == 2) 
                    queue.add(new int[] {m, n});
            }
        }
        int round = 0; // 分钟数
        while (count > 0 && !queue.isEmpty()) {
            round++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                int[] orange = queue.poll();
                int m = orange[0];
                int n = orange[1];
                if (m - 1 >= 0 && grid[m - 1][n] == 1) {
                    grid[m - 1][n] = 2;
                    count--;
                    queue.add(new int[] {m - 1, n});
                }
                if (m + 1 < M && grid[m + 1][n] == 1) {
                    grid[m + 1][n] = 2;
                    count--;
                    queue.add(new int[] {m + 1, n});
                }
                if (n - 1 >= 0 && grid[m][n - 1] == 1) {
                    grid[m][n - 1] = 2;
                    count--;
                    queue.add(new int[] {m, n - 1});
                }
                if (n + 1 < N && grid[m][n + 1] == 1) {
                    grid[m][n + 1] = 2;
                    count--;
                    queue.add(new int[] {m, n + 1});
                }
            }
        }
        return count > 0 ? -1 : round;
    }
}