技術標籤：leetcode貪心演算法dfs

無重疊區間

給定一個區間的集合，找到需要移除區間的最小數量，使剩餘區間互不重疊。

注意:

可以認為區間的終點總是大於它的起點。
區間 [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

解釋: 你不需要移除任何區間，因為它們已經是無重疊的了。

來源：力扣（LeetCode）
連結：https://leetcode-cn.com/problems/non-overlapping-intervals
著作權歸領釦網路所有。商業轉載請聯絡官方授權，非商業轉載請註明出處。

動態規劃：將區間按照起點排序

我們首先自定義一個按起點排序的函式：

//按陣列第一個元素排序
sort(intervals.begin(), intervals.end(), [](const vector<int>& u, const vector<int>& v) {
    return u[0] < v[0];
});
 

我們維持一個dp陣列，它表示前 i 個區間可以維持的最多區間數，那麼可以最少刪除就是intervals.size() - max(dp[i])。

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size() == 0) return 0; //沒有元素刪除0
        //按照區間起點對intervals排序
        sort(intervals.begin(), intervals.end(), [](const vector<int>& u, const vector<int>& v) {
            return u[0] < v[0];
        });
        vector<int> dp(intervals.size()); //dp陣列，代表前i位置可以留下的最多區間數
        dp[0] = 1; //只有一個區間時dp[i] = 1
        int res = 1; //只有一個區間時res = 1
        for(int i = 1;i < intervals.size();i ++){
            int Max = 0; //前i個位置維持的最長長度
            for(int j = i-1;j >= 0;j --) { //從後往前找，前面任意一個區間的終點都有超過i位置的可能
                if(intervals[j][1] <= intervals[i][0]) Max = max(dp[j],Max); //Max更新
                dp[i] = Max + 1; //i位置長度等於前i個位置維持的最長長度加上當前位置
                res = max(dp[i],res); //res更新
            }
        }
        return intervals.size()-res; //給出最佳方案
    }
};
 

時間極差，複雜度o(n*n)。

本題要求“找到需要移除區間的最小數量”，也就是說要更多的保留集合中的區間，對於有重疊的區間，我們應該儘可能刪去跨度較大的區間。

貪心演算法：按照起點排序

按照起點排序的話，對於目前遍歷到的區間 i，如果

①我的起點比上一個區間的終點小，那麼我們為了給後面的區間更多留下來的可能性，我就選擇退出

②如果我的起點比上一個區間的終點大，那麼我們倆互不影響

③我的起點比上一個區間的終點大，並且我的終點比上一個區間的終點小，那麼不好意思了，你走我留下

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size() == 0) return 0;
        sort(intervals.begin(), intervals.end(), [](const vector<int>& u, const vector<int>& v) {
            return u[0] < v[0];
        });
        int end = intervals[0][1]; //第一個區間終點
        int prev = 0; //上一個留下來的區間
        int count = 0; //刪除區間個數
        for(int i = 1;i < intervals.size();i ++){
            if(intervals[prev][1] > intervals[i][0]){ //我和上一個區間有重疊
                if(intervals[prev][1] > intervals[i][1]) prev = i; //我的終點小於上一個的終點，我留下來-情況3
                count ++; //有重疊必淘汰一個
            }else prev = i; //無重疊繼續
        }
        return count;
    }
};

時間複雜度降到了o(nlogn)，一下子好看起來了。

貪心演算法：按照終點排序

如果按照終點來排序，涉及到的情況就更少了，只要有當前區間的起點大於上一個區間的起點，直接跳過，count++。

class Solution {
public:
    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
        if(intervals.size() == 0) return 0;
        sort(intervals.begin(), intervals.end(), [](const vector<int>& u, const vector<int>& v) {
            return u[1] < v[1]; 
        }); //按照終點排序
        int end = intervals[0][1]; //第一個區間終點
        int count = 0; //刪除區間個數
        for(int i = 1;i < intervals.size();i ++){
            if(intervals[i][0] >= end){ //無重疊
                end = intervals[i][1]; //end更新
            }else count ++; //有重疊跳過
        }
        return count;
    }
};

複雜度也是o(nlogn)