无重叠区间+用最少数量的箭引爆气球

最新推荐文章于 2024-06-10 09:01:53 发布

Better-1

最新推荐文章于 2024-06-10 09:01:53 发布

阅读量96

点赞数

分类专栏：剑指

本文链接：https://blog.csdn.net/caihuanqia/article/details/109291000

版权

剑指专栏收录该内容

192 篇文章 4 订阅

订阅专栏

给定一个区间的集合，找到需要移除区间的最小数量，使剩余区间互不重叠。

注意:
可以认为区间的终点总是大于它的起点。
区间 [1,2] 和 [2,3] 的边界相互“接触”，但没有相互重叠。
示例 1:
输入: [ [1,2], [2,3], [3,4], [1,3] ]
输出: 1
解释: 移除 [1,3] 后，剩下的区间没有重叠。

这道题要注意的地方主要有：

先排序，可以按结束时间／开始时间
越早结束肯定是越好的，后面的时间可以进行更多的活动。
原本的错误思想是，每次保留最小区间，其实是不对的。小区间不代表就一定是最优的，如果刚好卡在两个较大的区间的中间，那么就是两个大区间更加合适。
所以，考虑的时候，其实只要对有交叠的区间进行操作就可以了，如果有交叠，那么就保留早结束的。

说到底就是对有交叠的区间进行操作。

按终止时间排序

在这里插入图片描述
按终止时间排序，只要下一个interval的起始点小于上一个保留intertval的终止点，那么就要删去。最后的记过就是首尾不交叉的区间。

class Solution(object):
    def eraseOverlapIntervals(self, intervals):
        if not intervals:
            return 0
        intervals = sorted(intervals, key = lambda x:x[1]) # 按终止时间排序
        sign = intervals[0]
        record = []
        num = 0 
        for i in range(1, len(intervals)):
            if intervals[i][0] < sign[1]:
                num += 1
            else:
                sign = intervals[i]
        return num

按开始时间排序

在这里插入图片描述
也就是只有两种情况，不是交叠就是包含，交叠肯定是删去下一个，包含的话保留下一个，那么其实只要对终点的位置进行判别即可。区间的大小判别是错的，可能区间小，晚结束。

按开始时间排序，那么，对于有交叠的部分，肯定也是越先结束越好，只要下一个的终点大于保留interval的终点，那么删除下一个interval；反之删除上一个保留interval。

class Solution(object):
    def eraseOverlapIntervals(self, intervals):
        # 按开始时间排序
        if not intervals:
            return 0
        intervals = sorted(intervals, key = lambda x:x[0]) # 按开始时间排序        
        sign = intervals[0]
        num = 0
        for i in range(1, len(intervals)):
            if intervals[i][0] < sign[1]:
                # 下面的判断是错误的，要的还是先结束的好，如果只是区间小了，但是晚结束，也不是好的。
                # 分清楚，只有两种情况，就是包含和交叉，交叉的话肯定是删除了后者。
                # if (sign[1] - sign[0]) > (intervals[i][1]-intervals[i][0]):
                #     num += 1
                #     sign = intervals[i]

                # elif (sign[1] - sign[0]) <= (intervals[i][1]-intervals[i][0]):
                #     num += 1
                if sign[1] > intervals[i][1]:
                    num += 1
                    sign = intervals[i]

                elif sign[1] <= intervals[i][1]:
                    num += 1
                    
            else:
                sign = intervals[i]
        return num

用最少数量的箭引爆气球

同样的题目，都是区间问题。
在二维空间中有许多球形的气球。对于每个气球，提供的输入是水平方向上，气球直径的开始和结束坐标。由于它是水平的，所以纵坐标并不重要，因此只要知道开始和结束的横坐标就足够了。开始坐标总是小于结束坐标。

一支弓箭可以沿着 x 轴从不同点完全垂直地射出。在坐标 x 处射出一支箭，若有一个气球的直径的开始和结束坐标为 xstart，xend，且满足 xstart ≤ x ≤ xend，则该气球会被引爆。可以射出的弓箭的数量没有限制。弓箭一旦被射出之后，可以无限地前进。我们想找到使得所有气球全部被引爆，所需的弓箭的最小数量。

给你一个数组 points ，其中 points [i] = [xstart,xend] ，返回引爆所有气球所必须射出的最小弓箭数。

示例 1：

输入：points = [[10,16],[2,8],[1,6],[7,12]]
输出：2
解释：对于该样例，x = 6 可以射爆 [2,8],[1,6] 两个气球，以及 x = 11 射爆另外两个气球
示例 2：

输入：points = [[1,2],[3,4],[5,6],[7,8]]
输出：4
示例 3：

输入：points = [[1,2],[2,3],[3,4],[4,5]]
输出：2

题意的理解很重要，其实就是在X轴上沿着Y轴射出，可以刺破该点上的所有气球。所以，只要有重叠区间，就可以在重叠的点上射出箭。所以，问题就转化为了如何划分区间，使得最终得到的重叠区间的团数尽可能少。

class Solution:
    def findMinArrowShots(self, points: List[List[int]]) -> int:
        # 只要有重叠， 就可以一起破掉，重叠越多越好，

        if not points:
            return 0
        
        num = len(points)
        points = sorted(points, key = lambda x:x[1])
        sign = points[0]
        for i in range(1, len(points)):
            if points[i][0] <= sign[1]:
                num -= 1
            else:
                sign = points[i]
        
        return num