leetcode 994腐烂的橘子

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

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，任何与腐烂的橘子（在 4 个正方向上）相邻的新鲜橘子都会腐烂。

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

示例 1：

输入：[[2,1,1],[1,1,0],[0,1,1]]
输出：4
示例 2：

输入：[[2,1,1],[0,1,1],[1,0,1]]
输出：-1
解释：左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个正向上。
示例 3：

输入：[[0,2]]
输出：0
解释：因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0 。

提示：

1 <= grid.length <= 10
1 <= grid[0].length <= 10
grid[i][j] 仅为 0、1 或 2

思路: 适合广度搜索，广度搜索是以层的概念来扩展，同时，
这个地方必须首先将全部的烂橘子都加入，再同时以烂橘子这一层开始bfs,
最后结束后，再遍历一遍数组，遇到没烂的橘子，就返回-1，否则返回path-1.
这里为啥要先将烂橘子都加入，因为存在类似[[2,2,2,1,1]]这种情况。如果只单加第一个2那么烂橘子不能蔓延
如果二维数组存在多个烂橘子，那烂橘子是同时向周围蔓延，所以是以{所有的烂橘子这一层}–>{向未烂蔓延}。

class Solution {

    static class Node{
        int r;
        int c;
        public Node(int i,int j){
            this.r = i;
            this.c = j;
        }
    }
    static final int[][] f = {{-1,0},{1,0},{0,1},{0,-1}};

    int path = 0;
    public int orangesRotting(int[][] grid) {
       
        Queue<Node> nodes = new LinkedList<>();
        for(int i =0;i<grid.length;i++)
        {   
            for(int j = 0;j<grid[0].length;j++)
            {
                if(grid[i][j]==2)
                {
                    nodes.add(new Node(i,j));
                }
            }
        }

            while(!nodes.isEmpty())
            {
            int size = nodes.size();
            path++;
            while(size-->0){
            Node root = nodes.poll();
            int r = root.r;
            int c = root.c;     // 1.加标记
            for(int[] m:f)
            {
                int h = r+m[0];
                int l = c+m[1];
                if(h<0||h>=grid.length
                    ||l<0||l>=grid[0].length||grid[h][l]==0||grid[h][l]==2)
                    continue;
                grid[h][l]=2;
                nodes.add(new Node(h,l));
            }          
          }
           
        }

        for(int i = 0;i<grid.length;i++)
        {
            for(int j = 0;j<grid[0].length;j++)
            {
                if(grid[i][j]==1)
                    return -1;
            }
        }
        if(path>0)
        return path-1;
        return path;

    }
    
}

bfs遍历过程中需要注意的点：
1.在每一层中处理当前节点问题，需要去加标记重复遍历吗？
2.向周围遍历的时候，能添加的条件，这是重复入队的因素，需要考虑。或者找到终点的结果return 出去。
3.找到新节点需要加标记防止重复标记吗？