435. 无重叠区间

非常机智的算法

想要找到无重叠区间，想的是找到的是最合适留下来的区间

所以我们将按照区间的后段大小进行排序将最在前的留下即可

真的非常机智

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        intervals.sort(key = lambda x: (x[1],x[0]))
        n = 1
        mins = intervals[0][1]
        for j in intervals:
            if j[0] >= mins:
                n += 1
                mins = j[1]
        return len(intervals) - n

763.划分字母区间

可以分为如下两步：

统计每一个字符最后出现的位置
从头遍历字符，并更新字符的最远出现下标，如果找到字符最远出现位置下标和当前下标相等了，则找到了分割点

class Solution:
    def partitionLabels(self, s: str) -> List[int]:
        record = {}
        for i in range(len(s)):
                record[s[i]] = i
        maxs = record[s[0]]
        ans = []
        before = -1
        for i in range(len(s)):
            maxs = max(maxs, record[s[i]])
            if maxs == i:
                ans.append(i-before)
                before = i
        return ans

56. 合并区间

这题和以前的题目很像，确定start的大小顺序以后,一个一个进行合并

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort(key = lambda x : (x[0], x[1]))
        maxs = intervals[0][1]
        begin = intervals[0][0]
        ans = []
        for j in intervals:
            if j[0] <= maxs:
                maxs = max(maxs, j[1])
            else:
                ans.append([begin, maxs])
                begin = j[0]
                maxs = j[1]
        ans.append([begin, maxs])
        return ans

738.单调递增的数字

首先思考：

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

然后确定是从前向后还是从后向前

从前向后的以后需要向前进行更改，所以我们从后向前进行

坑还是挺多的，需要注意如果有一个变成了9，那之前的所有都要变成9

class Solution:
    def monotoneIncreasingDigits(self, n: int) -> int:
        ans = []
        ans.append(n%10)
        n = n//10
        i = 0
        while n > 0:
            k = n%10
            if k > ans[i]:
                ans[i] = 9
                ans.append(k-1)
                i += 1
            else:
                ans.append(k)
                i += 1
            n = n//10
        result = 0
        flag = True
        while (i >= 0):
            if flag:
                result = result * 10 + ans[i]
            else:
                result = result * 10 + 9
            if ans[i] == 9:
                flag = False
            i -= 1
        return result

968.监控二叉树

# 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
class Solution:
    def minCameraCover(self, root: TreeNode) -> int:
        # 定义递归函数
        result = [0]  # 用于记录摄像头的安装数量
        if self.traversal(root, result) == 0:
            result[0] += 1

        return result[0]

        
    def traversal(self, cur: TreeNode, result: List[int]) -> int:
        if not cur:
            return 2

        left = self.traversal(cur.left, result)
        right = self.traversal(cur.right, result)

        # 情况1: 左右节点都有覆盖
        if left == 2 and 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 左节点覆盖，右节点无覆盖
        if left == 0 or right == 0:
            result[0] += 1
            return 1

        # 情况3:
        # left == 1 && right == 2 左节点有摄像头，右节点有覆盖
        # left == 2 && right == 1 左节点有覆盖，右节点有摄像头
        # left == 1 && right == 1 左右节点都有摄像头
        if left == 1 or right == 1:
            return 2