广度优先搜索（BFS）题目解析（层序遍历，腐烂的橘子）

层序遍历

力扣994、腐烂的橘子

思路：1、统计当前新鲜橘子，将腐烂的橘子放入队列中

           2、bfs从烂橘子位置开始遍历，并将周围方向的橘子腐烂，同时新的腐烂橘子压入队列

           3、上一层腐烂的橘子继续向四周蔓延，直到最后队列为空，统计时间。

class Solution {
    public int orangesRotting(int[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        //用于上下左右四个方向的遍历；
        int[] dx = {1, 0, 0, -1};
        int[] dy = {0, 1, -1, 0};
        int time = 0;
        //队列中存放腐烂的橘子
        Queue<int[]> que = new LinkedList<>();
        int count = 0; //新鲜橘子个数
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < m; j++) {
                if(grid[i][j] == 2) {
                    que.add(new int[]{i, j});
                } else if(grid[i][j] == 1) {
                    count++;
                }
            }
        }
        if(count == 0) return 0;
        //进行一次广度优先搜索，和层序遍历一样；
        while(!que.isEmpty()) {
            int size = que.size();
            while(size > 0) {
                int[] temp = que.poll();
                //进行四个方向的遍历
                for(int j = 0; j < 4; j++) {
                    int mx = temp[0] + dx[j];
                    int my = temp[1] + dy[j];
                    if(mx >= 0 && my >= 0 && mx < n && my < m && grid[mx][my] == 1) {
                        grid[mx][my] = 2;
                        que.add(new int[]{mx, my});
                        count--;
                    }
                }
                size--;
            }
            time++;
        }
        return count == 0 ? time - 1 : -1;

    }
}