994. 腐烂的橘子

994. 腐烂的橘子 - 力扣（LeetCode）

思路：

多个点同时向外扩展一个单位，使用bfs，每次把当前的所有腐烂的橘子取出，然后放入新腐烂的橘子。

因为可能存在橘子永远无法腐烂，所以，如果腐烂的橘子数目小于总的橘子数目，说明存在橘子没有腐烂。在将初始的腐烂橘子放入队列的时候，同时要统计橘子的数目。

总结：

多个点同时向外扩展一个单位，使用bfs。

代码：

class Solution {
    private int[][] dirs = {
        {1, 0},
        {-1, 0},
        {0, 1},
        {0, -1}
    };
    public int orangesRotting(int[][] grid) {
        int m = grid.length;
        int n = grid[0].length;
        // 所有的橘子个数
        int cnt0 = 0;
        // 腐烂的橘子的个数
        int cnt = 0;
        Deque<int[]> que = new ArrayDeque<>();
        // 记录初始状态
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(grid[i][j] == 2) {
                    que.offer(new int[]{i, j});
                    cnt++;
                }
                if(grid[i][j] != 0) {
                    cnt0++;
                }
            }
        }
        // 如果不存在橘子返回0
        if(cnt0 == 0) return 0;
        int t = -1;
        // bfs
        while(!que.isEmpty()) {
            int size = que.size();
            t++;
            while(size-->0) {
                int[] pos = que.poll();
                for(int[] dir : dirs) {
                    int i = pos[0] + dir[0];
                    int j = pos[1] + dir[1];
                    if(0 <= i && i < m && 0 <= j && j < n && grid[i][j] == 1) {
                        grid[i][j] = 2;
                        cnt++;
                        que.offer(new int[]{i, j});
                    }
                }
            }
        }
        return cnt0 - cnt == 0 ? t : -1;
    }
}