为了得到无重叠区间,煞费苦心

开发 前端
给定一个区间的集合,找到需要移除区间的最小数量,使剩余区间互不重叠。注意: 可以认为区间的终点总是大于它的起点。区间 [1,2] 和 [2,3] 的边界相互“接触”,但没有相互重叠。

[[438794]]

无重叠区间

力扣题目链接:https://leetcode-cn.com/problems/non-overlapping-intervals

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

注意: 可以认为区间的终点总是大于它的起点。区间 [1,2] 和 [2,3] 的边界相互“接触”,但没有相互重叠。

示例 1:

  • 输入: [ [1,2], [2,3], [3,4], [1,3] ]
  • 输出: 1
  • 解释: 移除 [1,3] 后,剩下的区间没有重叠。

示例 2:

  • 输入: [ [1,2], [1,2], [1,2] ]
  • 输出: 2
  • 解释: 你需要移除两个 [1,2] 来使剩下的区间没有重叠。

示例 3:

  • 输入: [ [1,2], [2,3] ]
  • 输出: 0
  • 解释: 你不需要移除任何区间,因为它们已经是无重叠的了。

思路

相信很多同学看到这道题目都冥冥之中感觉要排序,但是究竟是按照右边界排序,还是按照左边界排序呢?

这其实是一个难点!

按照右边界排序,就要从左向右遍历,因为右边界越小越好,只要右边界越小,留给下一个区间的空间就越大,所以从左向右遍历,优先选右边界小的。

按照左边界排序,就要从右向左遍历,因为左边界数值越大越好(越靠右),这样就给前一个区间的空间就越大,所以可以从右向左遍历。

如果按照左边界排序,还从左向右遍历的话,其实也可以,逻辑会有所不同。

一些同学做这道题目可能真的去模拟去重复区间的行为,这是比较麻烦的,还要去删除区间。

题目只是要求移除区间的个数,没有必要去真实的模拟删除区间!

我来按照右边界排序,从左向右记录非交叉区间的个数。最后用区间总数减去非交叉区间的个数就是需要移除的区间个数了。

此时问题就是要求非交叉区间的最大个数。

右边界排序之后,局部最优:优先选右边界小的区间,所以从左向右遍历,留给下一个区间的空间大一些,从而尽量避免交叉。全局最优:选取最多的非交叉区间。

局部最优推出全局最优,试试贪心!

这里记录非交叉区间的个数还是有技巧的,如图:

无重叠区间

区间,1,2,3,4,5,6都按照右边界排好序。

每次取非交叉区间的时候,都是可右边界最小的来做分割点(这样留给下一个区间的空间就越大),所以第一条分割线就是区间1结束的位置。

接下来就是找大于区间1结束位置的区间,是从区间4开始。那有同学问了为什么不从区间5开始?别忘已经是按照右边界排序的了。

区间4结束之后,在找到区间6,所以一共记录非交叉区间的个数是三个。

总共区间个数为6,减去非交叉区间的个数3。移除区间的最小数量就是3。

C++代码如下:

  1. class Solution { 
  2. public
  3.     // 按照区间右边界排序 
  4.     static bool cmp (const vector<int>& a, const vector<int>& b) { 
  5.         return a[1] < b[1]; 
  6.     } 
  7.     int eraseOverlapIntervals(vector<vector<int>>& intervals) { 
  8.         if (intervals.size() == 0) return 0; 
  9.         sort(intervals.begin(), intervals.end(), cmp); 
  10.         int count = 1; // 记录非交叉区间的个数 
  11.         int end = intervals[0][1]; // 记录区间分割点 
  12.         for (int i = 1; i < intervals.size(); i++) { 
  13.             if (end <= intervals[i][0]) { 
  14.                 end = intervals[i][1]; 
  15.                 count++; 
  16.             } 
  17.         } 
  18.         return intervals.size() - count
  19.     } 
  20. }; 
  • 时间复杂度:O(nlogn) ,有一个快排
  • 空间复杂度:O(1)

大家此时会发现如此复杂的一个问题,代码实现却这么简单!

总结

本题我认为难度级别可以算是hard级别的!

总结如下难点:

  • 难点一:一看题就有感觉需要排序,但究竟怎么排序,按左边界排还是右边界排。
  • 难点二:排完序之后如何遍历,如果没有分析好遍历顺序,那么排序就没有意义了。
  • 难点三:直接求重复的区间是复杂的,转而求最大非重复区间个数。
  • 难点四:求最大非重复区间个数时,需要一个分割点来做标记。

这四个难点都不好想,但任何一个没想到位,这道题就解不了。

一些录友可能看网上的题解代码很简单,照葫芦画瓢稀里糊涂的就过了,但是其题解可能并没有把问题难点讲清楚,然后自己再没有钻研的话,那么一道贪心经典区间问题就这么浪费掉了。

贪心就是这样,代码有时候很简单(不是指代码短,而是逻辑简单),但想法是真的难!

这和动态规划还不一样,动规的代码有个递推公式,可能就看不懂了,而贪心往往是直白的代码,但想法读不懂,哈哈。

所以我把本题的难点也一一列出,帮大家不仅代码看的懂,想法也理解的透彻!

补充

本题其实和452.用最少数量的箭引爆气球非常像,弓箭的数量就相当于是非交叉区间的数量,只要把弓箭那道题目代码里射爆气球的判断条件加个等号(认为[0,1][1,2]不是相邻区间),然后用总区间数减去弓箭数量 就是要移除的区间数量了。

把452.用最少数量的箭引爆气球代码稍做修改,就可以AC本题。

  1. class Solution { 
  2. public
  3.     // 按照区间右边界排序 
  4.     static bool cmp (const vector<int>& a, const vector<int>& b) { 
  5.         return a[1] < b[1]; 
  6.     } 
  7.     int eraseOverlapIntervals(vector<vector<int>>& intervals) { 
  8.         if (intervals.size() == 0) return 0; 
  9.         sort(intervals.begin(), intervals.end(), cmp); 
  10.  
  11.         int result = 1; // points 不为空至少需要一支箭 
  12.         for (int i = 1; i < intervals.size(); i++) { 
  13.             if (intervals[i][0] >= intervals[i - 1][1]) { 
  14.                 result++; // 需要一支箭 
  15.             } 
  16.             else {  // 气球i和气球i-1挨着 
  17.                 intervals[i][1] = min(intervals[i - 1][1], intervals[i][1]); // 更新重叠气球最小右边界 
  18.             } 
  19.         } 
  20.         return intervals.size() - result; 
  21.     } 
  22. }; 

这里按照 左区间遍历,或者按照右边界遍历,都可以AC,具体原因我还没有仔细看,后面有空再补充。

  1. class Solution { 
  2. public
  3.     // 按照区间左边界排序 
  4.     static bool cmp (const vector<int>& a, const vector<int>& b) { 
  5.         return a[0] < b[0]; 
  6.     } 
  7.     int eraseOverlapIntervals(vector<vector<int>>& intervals) { 
  8.         if (intervals.size() == 0) return 0; 
  9.         sort(intervals.begin(), intervals.end(), cmp); 
  10.  
  11.         int result = 1; // points 不为空至少需要一支箭 
  12.         for (int i = 1; i < intervals.size(); i++) { 
  13.             if (intervals[i][0] >= intervals[i - 1][1]) { 
  14.                 result++; // 需要一支箭 
  15.             } 
  16.             else {  // 气球i和气球i-1挨着 
  17.                 intervals[i][1] = min(intervals[i - 1][1], intervals[i][1]); // 更新重叠气球最小右边界 
  18.             } 
  19.         } 
  20.         return intervals.size() - result; 
  21.     } 
  22. }; 

本文转载自微信公众号「代码随想录」,可以通过以下二维码关注。转载本文请联系代码随想录公众号。

 

责任编辑:武晓燕 来源: 代码随想录
相关推荐

2015-10-19 11:14:17

Edge浏览器Windows 10

2020-05-21 11:23:08

微软LinuxWindows

2020-12-31 05:47:40

网格化网格通信

2020-07-23 16:00:38

Redis字符串Java

2020-03-16 09:26:56

开发技能代码

2013-11-28 10:09:33

大数据数据中心SDN

2024-06-13 17:06:03

2011-11-25 10:20:36

飞视美视频

2012-11-26 13:46:17

路由器交换机

2018-04-20 08:37:23

灾难恢复数据备份

2015-11-24 10:09:49

Windows 10TH2数据搜集

2009-03-25 08:45:33

AndroidGoogle移动OS

2009-10-30 11:32:23

2013-07-31 13:55:01

2011-03-07 13:24:15

2021-01-26 09:13:07

前端开发者程序员

2019-03-21 09:45:11

TypeScript编程语言Javascript

2012-01-05 09:26:56

App Store作产品赚钱

2016-12-16 12:06:09

数据分析大数据

2009-12-02 09:49:32

公众形象微软
点赞
收藏

51CTO技术栈公众号