数组

大家好，我是老马。

今天我们一起来学习一下数组这种数据结构。

主要知识

数组需要拆分下面几个部分：

1. 理论介绍

2. 源码分析

3. 数据结构实现？

4. 题目练习（按照算法思想分类）

5. 梳理对应的 sdk 包

6. 应用实战

因为这个是 leetcode 系列，所以重点是 4、5(对4再一次总结)。

为了照顾没有基础的小伙伴，会简单介绍一下1的基础理论。

简单介绍1，重点为4。其他不是本系列的重点。

994. 腐烂的橘子

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

值 0 代表空单元格；
值 1 代表新鲜橘子；
值 2 代表腐烂的橘子。
每分钟，腐烂的橘子 周围 4 个方向上相邻 的新鲜橘子都会腐烂。

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

示例 1：

1

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

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

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

提示：

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

v1-基本 BFS

思路

1. BFS 每次有多个开始的节点

2）时间这个维度，其实用 BFS 更加简单，迭代完一次，认为+1 分钟。

3）什么场景下腐坏的句子再次进入队列？腐坏终止的条件是什么？

4. 如何判断是否以及全部腐坏？

解法

其实理解清楚的话，还好。

1）初始化，所有坏的入队列

2）取出所有坏的。4个方向感染新鲜的，新鲜的被感染再次进入队列

一次迭代走完，count ++

3. 结束之后，判断一下新鲜的数量总数即可

    public int orangesRotting(int[][] grid) {
        if(grid == null) {
            return 0;
        }

        int m = grid.length;
        int n = grid[0].length;

        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});
                }
            }
        }

        int count = 0;

        while(!queue.isEmpty()) {
            int size = queue.size();
            for(int i = 0; i < size; i++) {
                int[] pos = queue.poll();
                int x = pos[0];
                int y = pos[1];

                // 只有下一步的上下左右有新鲜的句子，才进入 queue
                // 上
                if(y > 0 && grid[x][y-1] == 1) {
                    grid[x][y-1] = 2;
                    queue.offer(new int[]{x,y-1});
                }
                // 下
                if(y < n-1 && grid[x][y+1] == 1) {
                    grid[x][y+1] = 2;
                    queue.offer(new int[]{x,y+1});
                }
                // 左
                if(x > 0 && grid[x-1][y] == 1) {
                    grid[x-1][y] = 2;
                    queue.offer(new int[]{x-1,y});
                }
                // 右
                if(x < m-1 && grid[x+1][y] == 1) {
                    grid[x+1][y] = 2;
                    queue.offer(new int[]{x+1, y});
                }
            }

            // 避免 queue 为空的情况
            if(!queue.isEmpty()) {
                //1min走1步
                count++;
            }
        }

        // check 是否都感染了
        int freshCount = 0;
        for(int i = 0; i < m; i++) {
            for(int j = 0; j < n; j++) {
                if(grid[i][j] == 1) {
                    freshCount++;
                }
            }
        }
        if(freshCount > 0) {
            return -1;
        }

        return count;
    }

效果

1ms 击败 99.97%