力扣每日一刷——DAY009---广度优先搜索 / 深度优先搜索（542. 01 矩阵&&994. 腐烂的橘子）

广度优先搜索 / 深度优先搜索

题目一

542. 01 矩阵

给定一个由 0 和 1 组成的矩阵 mat ，请输出一个大小相同的矩阵，其中每一个格子是 mat 中对应位置元素到最近的 0 的距离。
两个相邻元素间的距离为 1 。

解题思路

通过广度优先搜索，因为是矩阵，我们只需要判断上下左右是否为0即可。倘若其中一个不为0，则进行递归，让count递增，最后比大小，取最小值。
不过

class Solution {
    public int[][] updateMatrix(int[][] mat) {
        int colLen = mat.length;
        int rowLen = mat[0].length;
        /*将 1 置为 888, 防止语义混淆; ②: 为广度遍历准备*/
        Deque<int[]> queue = new LinkedList<>();
        for (int col = 0; col < colLen; col++)
            for (int row = 0; row < rowLen; row++)
                if (mat[col][row] == 1)
                    mat[col][row] = 10001;
                else
                    queue.add(new int[]{col, row});
        /*标识广度层数*/
        int[] last = queue.getLast();
        int size = 1;
        /*开始广度遍历*/
        while (!queue.isEmpty()) {
            /*取出坐标*/
            int[] first = queue.removeFirst();
            int col = first[0], row = first[1];
            /*判断四周 - 左右,上下*/
            if (row > 0 && mat[col][row - 1] > size) {
                mat[col][row - 1] = size;
                queue.add(new int[]{col, row - 1});
            }
            if (row < rowLen - 1 && mat[col][row + 1] > size) {
                mat[col][row + 1] = size;
                queue.add(new int[]{col, row + 1});
            }
            if (col > 0 && mat[col - 1][row] > size) {
                mat[col - 1][row] = size;
                queue.add(new int[]{col - 1, row});
            }
            if (col < colLen - 1 && mat[col + 1][row] > size) {
                mat[col + 1][row] = size;
                queue.add(new int[]{col + 1, row});
            }
            /*广度结束?*/
            if (first == last && !queue.isEmpty()) {
                last = queue.getLast();
                size++;
            }
        }

        return mat;
    }
}

题目二

994. 腐烂的橘子

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

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

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

解题思路

首先遍历桌子（数组），得到坏果的坐标（deque）和好果（good）的数量，进行判断
如果没有坏果，则有两种情况

桌子为空，则在第0分钟也就是开始的时候就没有新鲜的橘子，所以返回0
桌子不为空，但是上面都是好的橘子，则不可能会有坏的橘子，所以返回-1
如果有坏果
因为在之前已经记录下了坏果的坐标，所以每一次遍历，都将坏果上下左右，也就是4个正方向进行感染，并且记下新的坏果的坐标，将时间加一分钟（感染一次一分钟，也就是将count+1），并且将之前记录好果的数量减一（good-1）此时也分两种情况

桌子上都是坏果 也就是 good == 0 ，返回对应的时间 count
桌子上还有好的水果，不过因为周围为空，不能进行感染，所以 good > 0 ，根据题意，这个橘子永远不会发生腐烂，返回 -1

class Solution {
    public int orangesRotting(int[][] grid) {
        int count = 0;
        ArrayDeque<int[]> deque = new ArrayDeque<>();


        int lenx = grid.length;
        int leny = grid[0].length;

        int good = 0;
        for (int x = 0; x < lenx; x++) {
            for (int y = 0; y < leny; y++) {
                if (grid[x][y] == 2) deque.add(new int[]{x, y}); //记录下坏果的坐标
                if (grid[x][y] == 1) good++;                    //记录下好果的数量，后面进行对比
            }
        }
        //如果桌子上没有坏果，则进行对应的判断
        if(deque.size() == 0) return good == 0 ? 0 : -1;
        //用来记录坐标，上下左右
        int[] dx = {-1, 1, 0, 0};
        int[] dy = {0, 0, -1, 1};

        while (!deque.isEmpty()) {  // 每运行一分钟，将上一次坏果的坐标抛出，并且记录新的坐标，直到不能再感染为止
            int size = deque.size();
            for (int cou = 0; cou < size; cou++) { //取出所有的坏果
                int[] poll = deque.poll();
                int x = poll[0];
                int y = poll[1];
                for (int i = 0; i < 4; i++) {
                    int newx = x + dx[i];
                    int newy = y + dy[i];
                    //边界判断，以及只能感染好果也就是 grid[newx][newy] 等于一的
                    if (newx >= 0 && newy >= 0 && newx < lenx && newy < leny && grid[newx][newy] == 1) {
                        grid[newx][newy] = 2;               //将水果感染
                        good--;                             //好的水果数量减一
                        deque.add(new int[]{newx, newy});   //将新的坐标存入到集合，进行下一次感染（遍历）
                    }
                }
            }
            count++; 
        }
        return good == 0 ? count - 1 : -1;  //最后结果进行对比，如果还存在好的水果，则返回-1 否者返回 count-1
    }
}

作者：he-huan-b
链接：https://leetcode-cn.com/problems/rotting-oranges/solution/bfsyan-du-you-xian-suan-fa-kan-wan-jiu-h-w3oz/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。