代码随想录算法训练营第三十一天 | 56. 合并区间 ， 738.单调递增的数字 ， 968.监控二叉树

目录

 56. 合并区间

思路

方法一： 贪心

738.单调递增的数字

思路

方法一：暴力法

方法二：贪心1

方法三：贪心2

 方法四：贪心3

968.监控二叉树 

思路

确定遍历顺序

如何隔两个节点放一个摄像头

方法一：贪心

心得收获

---

 56. 合并区间

• 题目链接：力扣题目链接

• 文章讲解：代码随想录 

• 视频讲解：贪心算法，合并区间有细节！LeetCode：56.合并区间

给出一个区间的集合，请合并所有重叠的区间。

示例 1:

• 输入: intervals = [[1,3],[2,6],[8,10],[15,18]]
• 输出: [[1,6],[8,10],[15,18]]
• 解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2:

• 输入: intervals = [[1,4],[4,5]]
• 输出: [[1,5]]
• 解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。
• 注意：输入类型已于2019年4月15日更改。 请重置默认代码定义以获取新方法签名。

思路

大家如果认真做题的话，话发现和我们刚刚讲过的452. 用最少数量的箭引爆气球 和 435. 无重叠区间都是一个套路。

这几道题都是判断区间重叠，区别就是判断区间重叠后的逻辑，本题是判断区间重贴后要进行区间合并。

所以一样的套路，先排序，让所有的相邻区间尽可能的重叠在一起，按左边界，或者右边界排序都可以，处理逻辑稍有不同。

按照左边界从小到大排序之后，如果 intervals[i][0] <= intervals[i - 1][1] 即intervals[i]的左边界 <= intervals[i - 1]的右边界，则一定有重叠。（本题相邻区间也算重贴，所以是<=）

这么说有点抽象，看图：（注意图中区间都是按照左边界排序之后了）

​

知道如何判断重复之后，剩下的就是合并了，如何去模拟合并区间呢？

其实就是用合并区间后左边界和右边界，作为一个新的区间，加入到result数组里就可以了。如果没有合并就把原区间加入到result数组。

方法一： 贪心

class Solution:
    def merge(self, intervals):
        result = []
        if len(intervals) == 0:
            return result  # 区间集合为空直接返回

        intervals.sort(key=lambda x: x[0])  # 按照区间的左边界进行排序

        result.append(intervals[0])  # 第一个区间可以直接放入结果集中

        for i in range(1, len(intervals)):
            if result[-1][1] >= intervals[i][0]:  # 发现重叠区间
                # 合并区间，只需要更新结果集最后一个区间的右边界，因为根据排序，左边界已经是最小的
                result[-1][1] = max(result[-1][1], intervals[i][1])
            else:
                result.append(intervals[i])  # 区间不重叠

        return result

738.单调递增的数字

• 题目链接：力扣题目链接

• 文章讲解：代码随想录 

• 视频讲解：贪心算法，思路不难想，但代码不好写！LeetCode:738.单调自增的数字

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

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

示例 1:

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

示例 2:

• 输入: N = 1234
• 输出: 1234

示例 3:

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

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

思路

题目要求小于等于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

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

方法一：暴力法

class Solution:
    def checkNum(self, num):
        max_digit = 10
        while num:
            digit = num % 10
            if max_digit >= digit:
                max_digit = digit
            else:
                return False
            num //= 10
        return True

    def monotoneIncreasingDigits(self, N):
        for i in range(N, 0, -1):
            if self.checkNum(i):
                return i
        return 0

方法二：贪心1

class Solution:
    def monotoneIncreasingDigits(self, N: int) -> int:
        # 将整数转换为字符串
        strNum = str(N)
        # flag用来标记赋值9从哪里开始
        # 设置为字符串长度，为了防止第二个for循环在flag没有被赋值的情况下执行
        flag = len(strNum)
        
        # 从右往左遍历字符串
        for i in range(len(strNum) - 1, 0, -1):
            # 如果当前字符比前一个字符小，说明需要修改前一个字符
            if strNum[i - 1] > strNum[i]:
                flag = i  # 更新flag的值，记录需要修改的位置
                # 将前一个字符减1，以保证递增性质
                strNum = strNum[:i - 1] + str(int(strNum[i - 1]) - 1) + strNum[i:]
        
        # 将flag位置及之后的字符都修改为9，以保证最大的递增数字
        for i in range(flag, len(strNum)):
            strNum = strNum[:i] + '9' + strNum[i + 1:]
        
        # 将最终的字符串转换回整数并返回
        return int(strNum)

方法三：贪心2

class Solution:
    def monotoneIncreasingDigits(self, N: int) -> int:
        # 将整数转换为字符串
        strNum = list(str(N))

        # 从右往左遍历字符串
        for i in range(len(strNum) - 1, 0, -1):
            # 如果当前字符比前一个字符小，说明需要修改前一个字符
            if strNum[i - 1] > strNum[i]:
                strNum[i - 1] = str(int(strNum[i - 1]) - 1)  # 将前一个字符减1
                # 将修改位置后面的字符都设置为9，因为修改前一个字符可能破坏了递增性质
                for j in range(i, len(strNum)):
                    strNum[j] = '9'

        # 将列表转换为字符串，并将字符串转换为整数并返回
        return int(''.join(strNum))

 方法四：贪心3

class Solution:
    def monotoneIncreasingDigits(self, n: int) -> int:
        nums = str(n)
        flag = 1
        for i in range(len(nums)-1,0,-1):
            if nums[i-1] > nums[i]:
                nums = nums[:i-1]+str(int(nums[i-1])-1)+'9'*(len(nums)-i)
        return int(nums)

968.监控二叉树 

• 题目链接：力扣题目链接

• 文章讲解：代码随想录 

• 视频讲解：贪心算法，二叉树与贪心的结合，有点难...... LeetCode:968.监督二叉树

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

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

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

示例 1：

​

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

示例 2：

​

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

提示：

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

思路

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

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

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

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

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

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

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

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

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

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

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

确定遍历顺序

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

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

后序遍历代码如下：

def traversal(self,node:TreeNode,count:List[int]) -> int:

    // 空节点，该节点有覆盖
    if (终止条件): return 

    left = self.traversal(node.left)    // 左
    right = self.traversal(node.right)  // 右

    逻辑处理                            // 中
    return 

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

如何隔两个节点放一个摄像头

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

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

有如下三种：

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

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

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

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

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

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

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

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

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

接下来就是递推关系。

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

代码如下：

// 空节点，该节点有覆盖
if node is None :return 2

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

主要有如下四类情况：

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

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

如图：

​

代码如下：

// 左右节点都有覆盖
if left == 2 and right == 2:
    return 0

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

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

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

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

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

代码如下：

if left == 0 or right == 0:
    count[0] += 1
    return 1

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

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

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

代码如下：

if left == 1 or right == 1:return 2

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

​

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

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

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

​

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

方法一：贪心

class Solution:
    def minCameraCover(self, root: Optional[TreeNode]) -> int:
        if not root :return 0
        count = [0]
        result = self.traversal(root,count)
        if result == 0:
            count[0] += 1
        return count[0]
    def traversal(self,node:TreeNode,count:List[int]) -> int:
        # 节点的三种状态：0,1,2
        # 0代表该节点未覆盖
        # 1代表该节点有摄像头
        # 2代表该节点被覆盖
        # 为什么没有节点无摄像头的状态，因为无摄像头的状态分为两种：
        # 刚好是状态0和状态2
        if not node: return 2
        left = self.traversal(node.left,count)
        right = self.traversal(node.right,count)


        # 第一种情况，左右子树都被覆盖即状态2
        if left == 2 and right == 2:
            return 0
        
        # 第三种情况，左右孩子其中有一个是未覆盖
        # 第三种情况必须在第二种情况之前，左右其中至少有一个为1的这种情况包含了一种特殊情况：左0右1或者左1右0，
        # 这种情况即符合情况2也符合情况3，但是这种情况的正确处理操作是父节点加一个摄像头，所以得让第3种情况在前面，先判断这个特殊情况。
        if left == 0 or right == 0:
            count[0] += 1
            return 1
        # 第二种情况，左右孩子其中一个有摄像头，不管另一个什么状态
        if left == 1 or right == 1:
            return 2

心得收获

本题目中count计算摄像头的数目，不能定义为count = 0,因为int属于不可变类型，在递归中，每一层的count都不会相互影响，所以最终返回值永远都是0，而数组属于可变类型，在每一层的递归中，指向的都是同一个地址，所以修改count会影响所有