day31 第八章 贪心算法 part05

56. 合并区间

先排序，再合并

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort(key=lambda x:x[0])

        merged = []
        # merged.append(intervals[0])
        for i in range(len(intervals)):
            if not merged or intervals[i][0]>merged[-1][1]:
                merged.append(intervals[i])
            else:
                merged[-1][1] = max(merged[-1][1], intervals[i][1])


        return merged

738.单调递增的数字

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

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

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

class Solution:
    def monotoneIncreasingDigits(self, n: int) -> int:
        str_n = list(str(n))
        flag = len(str_n)
        # print(str_n)
        # result = []
        for i in range(len(str_n)-1, 0, -1):
            if str_n[i] < str_n[i-1]:
                flag = i
                str_n[i-1] = chr(ord(str_n[i-1])-1)

        for i in range(flag, len(str_n)):
            str_n[i] = '9'
        return int(''.join(str_n))
                

968.监控二叉树 （可跳过）

思路：监控都不在叶子节点，所以从底向上遍历，后序遍历，分3种情况，最后根节点也要判断一下。

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
# 1有监控，0无覆盖，2有覆盖
class Solution:
    result = 0
    def traversal(self, node: Optional[TreeNode]) -> int:
        if not node:
            return 2

        left = self.traversal(node.left)
        right = self.traversal(node.right)

        if left == 0 or right == 0:
            self.result += 1
            return 1
        
        if left == 1 or right == 1:
            return 2
        
        if left == 2 and right == 2:
            return 0

       
    def minCameraCover(self, root: Optional[TreeNode]) -> int:
        self.result = 0
        if self.traversal(root)==0:
            self.result += 1
        return self.result