[Leetcode] 435. Non-overlapping Intervals 解题报告

最新推荐文章于 2024-02-19 15:23:16 发布

原创最新推荐文章于 2024-02-19 15:23:16 发布 · 361 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#Leetcode #解题报告 #Greedy

IT公司面试习题专栏收录该内容

736 篇文章

订阅专栏

本文介绍了一个使用贪心算法解决区间重叠问题的方法。通过排序和遍历的方式，找到最小数量的需要移除的区间，使得剩余区间不再重叠。算法时间复杂度为O(nlogn)，空间复杂度为O(1)。

题目：

Given a collection of intervals, find the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping.

Note:

You may assume the interval's end point is always bigger than its start point.
Intervals like [1,2] and [2,3] have borders "touching" but they don't overlap each other.

Example 1:

Input: [ [1,2], [2,3], [3,4], [1,3] ]

Output: 1

Explanation: [1,3] can be removed and the rest of intervals are non-overlapping.

Example 2:

Input: [ [1,2], [1,2], [1,2] ]

Output: 2

Explanation: You need to remove two [1,2] to make the rest of intervals non-overlapping.

Example 3:

Input: [ [1,2], [2,3] ]

Output: 0

Explanation: You don't need to remove any of the intervals since they're already non-overlapping.

思路：

仔细分析可以知道这道题目其实是比较简单的，可以用贪心算法：首先对intervals进行排序，然后遍历：每当遇到重合区域时，我们需要erase一个interval，更新end为两个interval的更靠左者（这是本题思路的关键：如果当前interval的end更靠右，则意味着将要删除当前interval，否则意味着要删除的是前面的某个interval，由于intevals是有序的，所以可推出前面某个interval完全包含了当前interval，因此删除前面的这个interval是安全的）；而如果没有重合，则直接更新end为新的interval的end即可。算法的时间复杂度是O(nlogn)，这是由于排序的缘故所致；空间复杂度则为O(1)。

代码：

/**
 * Definition for an interval.
 * struct Interval {
 *     int start;
 *     int end;
 *     Interval() : start(0), end(0) {}
 *     Interval(int s, int e) : start(s), end(e) {}
 * };
 */
class Solution {
public:
    int eraseOverlapIntervals(vector<Interval>& intervals) {
        if (intervals.size() == 0) {
            return 0;
        }
        sort(intervals.begin(), intervals.end(), IntervalComp);
        int end = intervals[0].end, ret = 0;
        for (int i = 1; i < intervals.size(); ++i) {
            if (intervals[i].start < end) {        // need to erase, and we erase the one whose end is larger
                ++ret;
                end = min(intervals[i].end, end);
            }
            else {                                 // do not need to erase, so we update the end
                end = intervals[i].end;
            }
        }
        return ret;
    }
private:
    struct IntervalCompare {
        bool operator() (const Interval &a, const Interval &b) const {
            if (a.start < b.start) {
                return true;
            }
            else if (a.start > b.start) {
                return false;
            }
            else {
                return a.end < b.end;
            }
        }
    } IntervalComp;
};