代码随想录算法训练营Day35 | 435. 无重叠区间、763.划分字母区间、56. 合并区间 | Python | 个人记录向

435. 无重叠区间

代码随想录：435. 无重叠区间
Leetcode：435. 无重叠区间

做题

无思路。

基于左边界的贪心算法

有点难理解，需要仔细琢磨。

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        if not intervals:
            return 0
        
        intervals.sort(key=lambda x: x[0])  # 按照左边界升序排序
        count = 0  # 记录重叠区间数量
        
        for i in range(1, len(intervals)):
            if intervals[i][0] < intervals[i - 1][1]:  # 存在重叠区间
                intervals[i][1] = min(intervals[i - 1][1], intervals[i][1])  # 更新重叠区间的右边界
                count += 1
        
        return count

时间复杂度：O(nlog n) ，有一个快排
空间复杂度：O(n)，有一个快排，最差情况(倒序)时，需要n次递归调用。因此确实需要O(n)的栈空间

基于左边界，把452.用最少数量的箭引爆气球代码稍做修改

会452题的话，这样看比较好理解。

class Solution:
    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
        if not intervals:
            return 0
        
        intervals.sort(key=lambda x: x[0])  # 按照左边界升序排序
        
        result = 1  # 不重叠区间数量，初始化为1，因为至少有一个不重叠的区间
        
        for i in range(1, len(intervals)):
            if intervals[i][0] >= intervals[i - 1][1]:  # 没有重叠
                result += 1
            else:  # 重叠情况
                intervals[i][1] = min(intervals[i - 1][1], intervals[i][1])  # 更新重叠区间的右边界
        
        return len(intervals) - result

763.划分字母区间

代码随想录：763.划分字母区间
Leetcode：763.划分字母区间

做题

思路：先遍历一遍，保存各字母的频次；再遍历一次，实时记录当前各字母的频次，当各字母频次均达上限时，才能跳入下一个字母区间。

看文章

可以分为如下两步：

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

自己动手实现一下：

class Solution:
    def partitionLabels(self, s: str) -> List[int]:
        pos_right = [0] * 26
        for i in range(len(s)):
            cur = ord(s[i]) - ord('a')
            pos_right[cur] = max(i, pos_right[cur])
        right = 0
        res = []
        count = 0
        for i in range(len(s)):
            cur = ord(s[i]) - ord('a')
            right = max(right, pos_right[cur])
            count += 1
            if i == right:
                res.append(count)
                count = 0
                right = i+1
        return res

上述是用数组储存，也可以用hash表存储。具体如下：

class Solution:
    def partitionLabels(self, s: str) -> List[int]:
        last_occurrence = {}  # 存储每个字符最后出现的位置
        for i, ch in enumerate(s):
            last_occurrence[ch] = i

        result = []
        start = 0
        end = 0
        for i, ch in enumerate(s):
            end = max(end, last_occurrence[ch])  # 找到当前字符出现的最远位置
            if i == end:  # 如果当前位置是最远位置，表示可以分割出一个区间
                result.append(end - start + 1)
                start = i + 1

        return result

时间复杂度：O(n)
空间复杂度：O(1)，使用的hash数组是固定大小

56. 合并区间

代码随想录：56. 合并区间
Leetcode：56. 合并区间

做题

有点类似射箭，排序后，对重叠的区间求并集即可。

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort(key=lambda x:x[0])
        left = intervals[0][0]
        right = intervals[0][1]
        res = []
        for i in range(1, len(intervals)):
            if intervals[i][0] <= right and intervals[i][1] >= left:
                left = min(intervals[i][0], left)
                right = max(intervals[i][1], right)
            else:
                res.append([left, right])
                left = intervals[i][0]
                right = intervals[i][1]
        res.append([left, right])
        return res

时间复杂度: O(nlogn)
空间复杂度: O(logn)，排序需要的空间开销

看文章

思路大体一致，处理细节有不同，代码如下：

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

以往忽略的知识点小结

• 找重叠/不重叠区间，主要是对比当前区间的左边界和上一个区间（可能是变化后）的右边界
• 划分字母区间：可以用最远字母的index，不需要用频次

个人体会

完成时间：1h20min。
心得：区间的题主要是理解判断思路。

​