算法入门第9天-搜索(中等2个)

1. leetcode542 - 01矩阵（中等）

1.1 题目描述

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

两个相邻元素间的距离为 1 。

示例 1：

输入：mat = [[0,0,0],[0,1,0],[0,0,0]]
输出：[[0,0,0],[0,1,0],[0,0,0]]

示例 2：

输入：mat = [[0,0,0],[0,1,0],[1,1,1]]
输出：[[0,0,0],[0,1,0],[1,2,1]]

提示：

m == mat.length
n == mat[i].length
1 <= m, n <= 104
1 <= m * n <= 104
mat[i][j] is either 0 or 1.
mat 中至少有一个 0

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/01-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1.2 代码实现

参考官答：

思路1：广度优先搜索

借助队列，首先将所有0元素入队，然后每次出队一个0，同时处理它的上下左右，并将其中符合条件的继续入队，重复上述过程。

class Solution {
	//上下左右方向
    static int[][] dir = {{-1,0},{1,0},{0,-1},{0,1}}; 

    public int[][] updateMatrix(int[][] mat) {
        int m = mat.length;
        int n = mat[0].length;
        int[][] dist = new int[m][n]; //结果数组
        boolean[][] seen = new boolean[m][n]; //记录已经处理过的元素，避免重复处理
        Queue<int[]> queue = new LinkedList<>(); //用一个int数组存储每个0元素的下标
        //所有0都入队
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(mat[i][j] == 0){
                    queue.offer(new int[]{i,j});
                    seen[i][j] = true;
                }
            }
        }
		// 0出队，同时它的上下左右入队
        while(!queue.isEmpty()){
            int[] cell = queue.poll();
            int i = cell[0], j = cell[1];
            for(int t = 0; t < 4; t++){
                int ni = i + dir[t][0];
                int nj = j + dir[t][1];
                if(ni >= 0 && ni < m && nj >= 0 && nj < n && !seen[ni][nj]){
                    dist[ni][nj] = dist[i][j] + 1;
                    queue.offer(new int[]{ni, nj});
                    seen[ni][nj] = true;
                }
            }
        }
        return dist;
    }
}

时间：O(mn)，最坏情况所有元素都是0，都要入队一次，出队一次；
空间：O(mn)，最坏情况所有元素都是0。
一些实现细节：
（1）static int[][] dir = {{-1,0},{1,0},{0,-1},{0,1}}; //注意二维数组用{}表示一个元素；
（2）Queue<int[]> queue = new LinkedList<>(); //用大小为2的int数组存储每个0元素的下标；

2. leetcode 994 - 腐烂的橘子(中等)

2.1 题目描述

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

值 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 。

示例4：提交错误时出现的

输入：[[0]]
输出：0

提示：

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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rotting-oranges
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

2.2 代码实现

我的提交：
思路参考上面542题的实现，设置2个变量batch和nextBatch来控制每一批入队元素的个数，方便计算结果count。

class Solution {
    static int[][] dir = {{-1,0}, {1,0}, {0,-1}, {0,1}};

    public int orangesRotting(int[][] grid) {
        int m = grid.length;
        int n= grid[0].length;
        int count = 0;
        int batch = 0; //当前层的2的个数
        int nextBatch = 0; //下一层的2的个数
        Queue<int[]> queue = new LinkedList<>();
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] == 2){
                    queue.offer(new int[]{i,j});
                    batch++;
                }
            }
        }
        
        while(!queue.isEmpty()){
            int[] cell = queue.poll();
            batch--;
            int i = cell[0], j = cell[1];
            for(int d = 0; d < 4;d++){
                int ni = i + dir[d][0];
                int nj = j + dir[d][1];
                if(ni >= 0 && ni < m && nj >= 0 && nj < n && grid[ni][nj] == 1){
                    grid[ni][nj] = 2; //设为2，表示腐烂
                    queue.offer(new int[]{ni, nj});
                    nextBatch++;
                }
            }
            //注意这里判断nextBatch是否为0，为0则无需进入下一层，没有这个判断count会比实际值大1.
            if(batch == 0 && nextBatch != 0){
                count++;
                batch = nextBatch;
                nextBatch = 0;
            }
        }

        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(grid[i][j] == 1){
                    return -1;
                }
            }
        }
        return count;
    }
}

时间：O(mn)；
空间：O(mn)。