【贪心算法】代码随想录算法训练营第三十七天 |738.单调递增的数字，968.监控二叉树，总结（待补充）

拼搏现实的明天。 2024-04-23 04:21 72阅读 0赞

## 738.单调递增的数字 ##

1、题目链接：[力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台][LeetCode_ -]

2、文章讲解：[代码随想录][Link 1]

3、题目：

给定一个非负整数 N，找出小于或等于 N 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。

（当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。）

示例 1:

*  输入: N = 10
 *  输出: 9

示例 2:

*  输入: N = 1234
 *  输出: 1234

示例 3:

*  输入: N = 332
 *  输出: 299

说明: N 是在 \[0, 10^9\] 范围内的一个整数。

4、视频讲解：

[贪心算法，依然是判断重叠区间 | LeetCode：435.无重叠区间\_哔哩哔哩\_bilibili][_ LeetCode_435._bilibili]

5、思路：

题目要求小于等于N的最大单调递增的整数，那么拿一个两位的数字来举例。

例如：98，一旦出现strNum\[i - 1\] > strNum\[i\]的情况（非单调递增），首先想让strNum\[i - 1\]--，然后strNum\[i\]给为9，这样这个整数就是89，即小于98的最大的单调递增整数。

这一点如果想清楚了，这道题就好办了。

此时是从前向后遍历还是从后向前遍历呢？

从前向后遍历的话，遇到strNum\[i - 1\] > strNum\[i\]的情况，让strNum\[i - 1\]减一，但此时如果strNum\[i - 1\]减一了，可能又小于strNum\[i - 2\]。

这么说有点抽象，举个例子，数字：332，从前向后遍历的话，那么就把变成了329，此时2又小于了第一位的3了，真正的结果应该是299。

那么从后向前遍历，就可以重复利用上次比较得出的结果了，从后向前遍历332的数值变化为：332 -> 329 -> 299

确定了遍历顺序之后，那么此时局部最优就可以推出全局，找不出反例，试试贪心。

### 总结 ###

本题只要想清楚个例，例如98，一旦出现strNum\[i - 1\] > strNum\[i\]的情况（非单调递增），首先想让strNum\[i - 1\]减一，strNum\[i\]赋值9，这样这个整数就是89。就可以很自然想到对应的贪心解法了。

想到了贪心，还要考虑遍历顺序，只有从后向前遍历才能重复利用上次比较的结果。

最后代码实现的时候，也需要一些技巧，例如用一个flag来标记从哪里开始赋值9。

1、将整数转换为字符串。
    2、将字符串转换为字符数组。
    3、从字符串的倒数第二个字符开始，遍历字符数组。
    4、如果当前字符大于下一个字符，则将当前字符减1，并记录当前位置作为新的起始位置。
    5、从新的起始位置开始，将字符数组中的字符全部设置为9。
    6、将字符数组转换为整数并返回
    class Solution {
        public int monotoneIncreasingDigits(int n) {
            String s = String.valueOf(n);
            char[] chars = s.toCharArray();
            int start = s.length();
            for (int i = s.length() - 2; i >= 0; i--) {
                if (chars[i] > chars[i + 1]) {
                    chars[i]--;
                    start = i + 1;
                }
            }
            for (int i = start; i < s.length(); i++) {
                chars[i] = '9';
            }
            return Integer.parseInt(String.valueOf(chars));
        }
    }

## 968.监控二叉树 ##

1、题目链接：[力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台][LeetCode_ - 1]

2、文章讲解：[代码随想录][Link 2]

3、题目：

给定一个二叉树，我们在树的节点上安装摄像头。

节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。

计算监控树的所有节点所需的最小摄像头数量。

示例 1：

![780123bcebde7c9bb6c19548a095c631.png][]

*  输入：\[0,0,null,0,0\]
 *  输出：1
 *  解释：如图所示，一台摄像头足以监控所有节点。

示例 2：

![b0925981d748f6d232c604bfda8f2ab3.png][]

*  输入：\[0,0,null,0,null,0,null,null,0\]
 *  输出：2
 *  解释：需要至少两个摄像头来监视树的所有节点。 上图显示了摄像头放置的有效位置之一。

提示：

*  给定树的节点数的范围是 \[1, 1000\]。
 *  每个节点的值都是 0。

4、视频链接：

[贪心算法，二叉树与贪心的结合，有点难...... LeetCode:968.监督二叉树\_哔哩哔哩\_bilibili][...... LeetCode_968._bilibili]

5、思路：

这道题目首先要想，如何放置，才能让摄像头最小的呢？

从题目中示例，其实可以得到启发，**我们发现题目示例中的摄像头都没有放在叶子节点上！**

这是很重要的一个线索，摄像头可以覆盖上中下三层，如果把摄像头放在叶子节点上，就浪费的一层的覆盖。

所以把摄像头放在叶子节点的父节点位置，才能充分利用摄像头的覆盖面积。

那么有同学可能问了，为什么不从头结点开始看起呢，为啥要从叶子节点看呢？

因为头结点放不放摄像头也就省下一个摄像头， 叶子节点放不放摄像头省下了的摄像头数量是指数阶别的。

**所以我们要从下往上看，局部最优：让叶子节点的父节点安摄像头，所用摄像头最少，整体最优：全部摄像头数量所用最少！**

局部最优推出全局最优，找不出反例，那么就按照贪心来！

此时，大体思路就是从低到上，先给叶子节点父节点放个摄像头，然后隔两个节点放一个摄像头，直至到二叉树头结点。

此时这道题目还有两个难点：

1.  二叉树的遍历
2.  如何隔两个节点放一个摄像头

#### [\#][Link 3]确定遍历顺序 ####

在二叉树中如何从低向上推导呢？

可以使用后序遍历也就是左右中的顺序，这样就可以在回溯的过程中从下到上进行推导了。

后序遍历代码如下：

int traversal(TreeNode* cur) {
    
        // 空节点，该节点有覆盖
        if (终止条件) return ;
    
        int left = traversal(cur->left);    // 左
        int right = traversal(cur->right);  // 右
    
        逻辑处理                            // 中
        return ;
    }

**注意在以上代码中我们取了左孩子的返回值，右孩子的返回值，即left 和 right， 以后推导中间节点的状态**

#### [\#][Link 4]如何隔两个节点放一个摄像头 ####

此时需要状态转移的公式，大家不要和动态的状态转移公式混到一起，本题状态转移没有择优的过程，就是单纯的状态转移！

来看看这个状态应该如何转移，先来看看每个节点可能有几种状态：

有如下三种：

*  该节点无覆盖
 *  本节点有摄像头
 *  本节点有覆盖

我们分别有三个数字来表示：

*  0：该节点无覆盖
 *  1：本节点有摄像头
 *  2：本节点有覆盖

大家应该找不出第四个节点的状态了。

**一些同学可能会想有没有第四种状态：本节点无摄像头，其实无摄像头就是 无覆盖 或者 有覆盖的状态，所以一共还是三个状态。**

**因为在遍历树的过程中，就会遇到空节点，那么问题来了，空节点究竟是哪一种状态呢？ 空节点表示无覆盖？ 表示有摄像头？还是有覆盖呢？**

回归本质，为了让摄像头数量最少，我们要尽量让叶子节点的父节点安装摄像头，这样才能摄像头的数量最少。

那么空节点不能是无覆盖的状态，这样叶子节点就要放摄像头了，空节点也不能是有摄像头的状态，这样叶子节点的父节点就没有必要放摄像头了，而是可以把摄像头放在叶子节点的爷爷节点上。

**所以空节点的状态只能是有覆盖，这样就可以在叶子节点的父节点放摄像头了**

接下来就是递推关系。

那么递归的终止条件应该是遇到了空节点，此时应该返回2（有覆盖），原因上面已经解释过了。

代码如下：

// 空节点，该节点有覆盖
    if (cur == NULL) return 2;

递归的函数，以及终止条件已经确定了，再来看单层逻辑处理。

主要有如下四类情况：

*  情况1：左右节点都有覆盖

左孩子有覆盖，右孩子有覆盖，那么此时中间节点应该就是无覆盖的状态了。

如图：

![1b735dafde784493d0c34855fd379382.png][]

代码如下：

// 左右节点都有覆盖
    if (left == 2 && right == 2) return 0;

*  情况2：左右节点至少有一个无覆盖的情况

如果是以下情况，则中间节点（父节点）应该放摄像头：

*  left == 0 && right == 0 左右节点无覆盖
 *  left == 1 && right == 0 左节点有摄像头，右节点无覆盖
 *  left == 0 && right == 1 左节点有无覆盖，右节点摄像头
 *  left == 0 && right == 2 左节点无覆盖，右节点覆盖
 *  left == 2 && right == 0 左节点覆盖，右节点无覆盖

这个不难理解，毕竟有一个孩子没有覆盖，父节点就应该放摄像头。

此时摄像头的数量要加一，并且return 1，代表中间节点放摄像头。

代码如下：

if (left == 0 || right == 0) {
        result++;
        return 1;
    }

*  情况3：左右节点至少有一个有摄像头

如果是以下情况，其实就是 左右孩子节点有一个有摄像头了，那么其父节点就应该是2（覆盖的状态）

*  left == 1 && right == 2 左节点有摄像头，右节点有覆盖
 *  left == 2 && right == 1 左节点有覆盖，右节点有摄像头
 *  left == 1 && right == 1 左右节点都有摄像头

代码如下：

if (left == 1 || right == 1) return 2;

**从这个代码中，可以看出，如果left == 1, right == 0 怎么办？其实这种条件在情况2中已经判断过了**，如图：

![0b120fed4b600881b205f8a18a7e9b5e.png][]

这种情况也是大多数同学容易迷惑的情况。

1.  情况4：头结点没有覆盖

以上都处理完了，递归结束之后，可能头结点 还有一个无覆盖的情况，如图：

![f710e6399f99f248a18054a0420b21d4.png][]

所以递归结束之后，还要判断根节点，如果没有覆盖，result++，代码如下：

int minCameraCover(TreeNode* root) {
        result = 0;
        if (traversal(root) == 0) { // root 无覆盖
            result++;
        }
        return result;
    }

以上四种情况我们分析完了，

### 总结 ###

本题的难点首先是要想到贪心的思路，然后就是遍历和状态推导。

在二叉树上进行状态推导，其实难度就上了一个台阶了，需要对二叉树的操作非常娴熟。

这道题目是名副其实的hard，大家感受感受。

class Solution {
        int res = 0;
    
        public int minCameraCover(TreeNode root) {
            // 对根节点的状态做检验,防止根节点是无覆盖状态 .
            if (minCame(root) == 0) {
                res++;
            }
            return res;
        }
    
        /**
         * 节点的状态值：
         * 0 表示无覆盖
         * 1 表示 有摄像头
         * 2 表示有覆盖
         * 后序遍历，根据左右节点的情况,来判读 自己的状态
         */
        public int minCame(TreeNode root) {
            if (root == null) {
                // 空节点默认为 有覆盖状态，避免在叶子节点上放摄像头
                return 2;
            }
            int left = minCame(root.left);
            int right = minCame(root.right);
    
            // 如果左右节点都覆盖了的话, 那么本节点的状态就应该是无覆盖,没有摄像头
            if (left == 2 && right == 2) {
                //(2,2)
                return 0;
            } else if (left == 0 || right == 0) {
                // 左右节点都是无覆盖状态,那 根节点此时应该放一个摄像头
                // (0,0) (0,1) (0,2) (1,0) (2,0)
                // 状态值为 1 摄像头数 ++;
                res++;
                return 1;
            } else {
                // 左右节点的 状态为 (1,1) (1,2) (2,1) 也就是左右节点至少存在 1个摄像头，
                // 那么本节点就是处于被覆盖状态
                return 2;
            }
        }
    }

## 总结： ##

在贪心系列开篇词[关于贪心算法，你该了解这些！(opens new window)][opens new window]中，我们就讲解了大家对贪心的普遍疑惑。

1.  贪心很简单，就是常识？

跟着一起刷题的录友们就会发现，**贪心思路往往很巧妙，并不简单**。

1.  贪心有没有固定的套路？

贪心无套路，也没有框架之类的，**需要多看多练培养感觉才能想到贪心的思路**。

1.  究竟什么题目是贪心呢？

Carl个人认为：如果找出局部最优并可以推出全局最优，就是贪心，如果局部最优都没找出来，就不是贪心，可能是单纯的模拟。（并不是权威解读，一家之辞哈）

但我们也不用过于强调什么题目是贪心，什么不是贪心，那就太学术了，毕竟学会解题就行了。

1.  如何知道局部最优推出全局最优，有数学证明么？

在做贪心题的过程中，如果再来一个数据证明，其实没有必要，手动模拟一下，如果找不出反例，就试试贪心。面试中，代码写出来跑过测试用例即可，或者自己能自圆其说理由就行了

就像是 要用一下 1 + 1 = 2，没有必要再证明一下 1 + 1 究竟为什么等于 2。（例子极端了点，但是这个道理）

相信大家读完[关于贪心算法，你该了解这些！(opens new window)][opens new window]，就对贪心有了一个基本的认识了。

### 贪心简单题 ###

以下三道题目就是简单题，大家会发现贪心感觉就是常识。是的，如下三道题目，就是靠常识，但我都具体分析了局部最优是什么，全局最优是什么，贪心也要贪的有理有据！

*  [贪心算法：分发饼干(opens new window)][opens new window 1]
 *  [贪心算法：K次取反后最大化的数组和(opens new window)][K_opens new window]
 *  [贪心算法：柠檬水找零(opens new window)][opens new window 2]

### [\#][Link 5]贪心中等题 ###

贪心中等题，靠常识可能就有点想不出来了。开始初现贪心算法的难度与巧妙之处。

*  [贪心算法：摆动序列(opens new window)][opens new window 3]
 *  [贪心算法：单调递增的数字(opens new window)][opens new window 4]

#### [\#][Link 6]贪心解决股票问题 ####

大家都知道股票系列问题是动规的专长，其实用贪心也可以解决，而且还不止就这两道题目，但这两道比较典型，我就拿来单独说一说

*  [贪心算法：买卖股票的最佳时机II(opens new window)][II_opens new window]
 *  [贪心算法：买卖股票的最佳时机含手续费(opens new window)][opens new window 5]本题使用贪心算法比较绕，建议后面学习动态规划章节的时候，理解动规就好

#### [\#][Link 7]两个维度权衡问题 ####

在出现两个维度相互影响的情况时，两边一起考虑一定会顾此失彼，要先确定一个维度，再确定另一个一个维度。

*  [贪心算法：分发糖果(opens new window)][opens new window 6]
 *  [贪心算法：根据身高重建队列(opens new window)][opens new window 7]

在讲解本题的过程中，还强调了编程语言的重要性，模拟插队的时候，使用C++中的list（链表）替代了vector(动态数组)，效率会高很多。

所以在[贪心算法：根据身高重建队列（续集）(opens new window)][opens new window 8]详细讲解了，为什么用list（链表）更快！

**大家也要掌握自己所用的编程语言，理解其内部实现机制，这样才能写出高效的算法！**

### [\#][Link 8]贪心难题 ###

这里的题目如果没有接触过，其实是很难想到的，甚至接触过，也一时想不出来，所以题目不要做一遍，要多练！

#### [\#][Link 9]贪心解决区间问题 ####

关于区间问题，大家应该印象深刻，有一周我们专门讲解的区间问题，各种覆盖各种去重。

*  [贪心算法：跳跃游戏(opens new window)][opens new window 9]
 *  [贪心算法：跳跃游戏II(opens new window)][II_opens new window 1]
 *  [贪心算法：用最少数量的箭引爆气球(opens new window)][opens new window 10]
 *  [贪心算法：无重叠区间(opens new window)][opens new window 11]
 *  [贪心算法：划分字母区间(opens new window)][opens new window 12]
 *  [贪心算法：合并区间(opens new window)][opens new window 13]

#### [\#][Link 10]其他难题 ####

[贪心算法：最大子序和(opens new window)][opens new window 14]其实是动态规划的题目，但贪心性能更优，很多同学也是第一次发现贪心能比动规更优的题目。

[贪心算法：加油站(opens new window)][opens new window 15]可能以为是一道模拟题，但就算模拟其实也不简单，需要把while用的很娴熟。但其实是可以使用贪心给时间复杂度降低一个数量级。

最后贪心系列压轴题目[贪心算法：我要监控二叉树！(opens new window)][opens new window 16]，不仅贪心的思路不好想，而且需要对二叉树的操作特别娴熟，这就是典型的交叉类难题了。

[LeetCode_ -]: https://leetcode.cn/problems/monotone-increasing-digits/
[Link 1]: https://www.programmercarl.com/0738.%E5%8D%95%E8%B0%83%E9%80%92%E5%A2%9E%E7%9A%84%E6%95%B0%E5%AD%97.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
[_ LeetCode_435._bilibili]: https://www.bilibili.com/video/BV1A14y1c7E1
[LeetCode_ - 1]: https://leetcode.cn/problems/binary-tree-cameras/
[Link 2]: https://www.programmercarl.com/0968.%E7%9B%91%E6%8E%A7%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE
[780123bcebde7c9bb6c19548a095c631.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/fd9eaf907ed84f3788275ca04177eaab.png
[b0925981d748f6d232c604bfda8f2ab3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/c0abe65cc34647a887b5c26688672c25.png
[...... LeetCode_968._bilibili]: https://www.bilibili.com/video/BV1SA411U75i
[Link 3]: https://www.programmercarl.com/0968.%E7%9B%91%E6%8E%A7%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E7%A1%AE%E5%AE%9A%E9%81%8D%E5%8E%86%E9%A1%BA%E5%BA%8F
[Link 4]: https://www.programmercarl.com/0968.%E7%9B%91%E6%8E%A7%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E5%A6%82%E4%BD%95%E9%9A%94%E4%B8%A4%E4%B8%AA%E8%8A%82%E7%82%B9%E6%94%BE%E4%B8%80%E4%B8%AA%E6%91%84%E5%83%8F%E5%A4%B4
[1b735dafde784493d0c34855fd379382.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/21c14bcd9be0443f86d2dbb11a9771c9.png
[0b120fed4b600881b205f8a18a7e9b5e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/a8a2ddca493b42a3ac13b1be14f30dda.png
[f710e6399f99f248a18054a0420b21d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/4a560da9d2d6441487aa50fdcbd3ce69.png
[opens new window]: https://programmercarl.com/%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%80.html
[opens new window 1]: https://programmercarl.com/0455.%E5%88%86%E5%8F%91%E9%A5%BC%E5%B9%B2.html
[K_opens new window]: https://programmercarl.com/1005.K%E6%AC%A1%E5%8F%96%E5%8F%8D%E5%90%8E%E6%9C%80%E5%A4%A7%E5%8C%96%E7%9A%84%E6%95%B0%E7%BB%84%E5%92%8C.html
[opens new window 2]: https://programmercarl.com/0860.%E6%9F%A0%E6%AA%AC%E6%B0%B4%E6%89%BE%E9%9B%B6.html
[Link 5]: https://www.programmercarl.com/%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%E6%80%BB%E7%BB%93%E7%AF%87.html#%E8%B4%AA%E5%BF%83%E4%B8%AD%E7%AD%89%E9%A2%98
[opens new window 3]: https://programmercarl.com/0376.%E6%91%86%E5%8A%A8%E5%BA%8F%E5%88%97.html
[opens new window 4]: https://programmercarl.com/0738.%E5%8D%95%E8%B0%83%E9%80%92%E5%A2%9E%E7%9A%84%E6%95%B0%E5%AD%97.html
[Link 6]: https://www.programmercarl.com/%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%E6%80%BB%E7%BB%93%E7%AF%87.html#%E8%B4%AA%E5%BF%83%E8%A7%A3%E5%86%B3%E8%82%A1%E7%A5%A8%E9%97%AE%E9%A2%98
[II_opens new window]: https://programmercarl.com/0122.%E4%B9%B0%E5%8D%96%E8%82%A1%E7%A5%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E6%97%B6%E6%9C%BAII.html
[opens new window 5]: https://programmercarl.com/0714.%E4%B9%B0%E5%8D%96%E8%82%A1%E7%A5%A8%E7%9A%84%E6%9C%80%E4%BD%B3%E6%97%B6%E6%9C%BA%E5%90%AB%E6%89%8B%E7%BB%AD%E8%B4%B9.html
[Link 7]: https://www.programmercarl.com/%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%E6%80%BB%E7%BB%93%E7%AF%87.html#%E4%B8%A4%E4%B8%AA%E7%BB%B4%E5%BA%A6%E6%9D%83%E8%A1%A1%E9%97%AE%E9%A2%98
[opens new window 6]: https://programmercarl.com/0135.%E5%88%86%E5%8F%91%E7%B3%96%E6%9E%9C.html
[opens new window 7]: https://programmercarl.com/0406.%E6%A0%B9%E6%8D%AE%E8%BA%AB%E9%AB%98%E9%87%8D%E5%BB%BA%E9%98%9F%E5%88%97.html
[opens new window 8]: https://programmercarl.com/%E6%A0%B9%E6%8D%AE%E8%BA%AB%E9%AB%98%E9%87%8D%E5%BB%BA%E9%98%9F%E5%88%97%EF%BC%88vector%E5%8E%9F%E7%90%86%E8%AE%B2%E8%A7%A3%EF%BC%89.html
[Link 8]: https://www.programmercarl.com/%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%E6%80%BB%E7%BB%93%E7%AF%87.html#%E8%B4%AA%E5%BF%83%E9%9A%BE%E9%A2%98
[Link 9]: https://www.programmercarl.com/%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%E6%80%BB%E7%BB%93%E7%AF%87.html#%E8%B4%AA%E5%BF%83%E8%A7%A3%E5%86%B3%E5%8C%BA%E9%97%B4%E9%97%AE%E9%A2%98
[opens new window 9]: https://programmercarl.com/0055.%E8%B7%B3%E8%B7%83%E6%B8%B8%E6%88%8F.html
[II_opens new window 1]: https://programmercarl.com/0045.%E8%B7%B3%E8%B7%83%E6%B8%B8%E6%88%8FII.html
[opens new window 10]: https://programmercarl.com/0452.%E7%94%A8%E6%9C%80%E5%B0%91%E6%95%B0%E9%87%8F%E7%9A%84%E7%AE%AD%E5%BC%95%E7%88%86%E6%B0%94%E7%90%83.html
[opens new window 11]: https://programmercarl.com/0435.%E6%97%A0%E9%87%8D%E5%8F%A0%E5%8C%BA%E9%97%B4.html
[opens new window 12]: https://programmercarl.com/0763.%E5%88%92%E5%88%86%E5%AD%97%E6%AF%8D%E5%8C%BA%E9%97%B4.html
[opens new window 13]: https://programmercarl.com/0056.%E5%90%88%E5%B9%B6%E5%8C%BA%E9%97%B4.html
[Link 10]: https://www.programmercarl.com/%E8%B4%AA%E5%BF%83%E7%AE%97%E6%B3%95%E6%80%BB%E7%BB%93%E7%AF%87.html#%E5%85%B6%E4%BB%96%E9%9A%BE%E9%A2%98
[opens new window 14]: https://programmercarl.com/0053.%E6%9C%80%E5%A4%A7%E5%AD%90%E5%BA%8F%E5%92%8C.html
[opens new window 15]: https://programmercarl.com/0134.%E5%8A%A0%E6%B2%B9%E7%AB%99.html
[opens new window 16]: https://programmercarl.com/0968.%E7%9B%91%E6%8E%A7%E4%BA%8C%E5%8F%89%E6%A0%91.html