[[439314]]

 合并區(qū)間

力扣題目鏈接：https://leetcode-cn.com/problems/merge-intervals

給出一個區(qū)間的集合，請合并所有重疊的區(qū)間。

示例 1:

• 輸入: intervals = [[1,3],[2,6],[8,10],[15,18]]
• 輸出: [[1,6],[8,10],[15,18]]
• 解釋: 區(qū)間 [1,3] 和 [2,6] 重疊, 將它們合并為 [1,6].

示例 2:

• 輸入: intervals = [[1,4],[4,5]]
• 輸出: [[1,5]]
• 解釋: 區(qū)間 [1,4] 和 [4,5] 可被視為重疊區(qū)間。
• 注意：輸入類型已于2019年4月15日更改。請重置默認代碼定義以獲取新方法簽名。

提示：

intervals[i][0] <= intervals[i][1]

思路

大家應該都感覺到了，此題一定要排序，那么按照左邊界排序，還是右邊界排序呢?

都可以!

那么我按照左邊界排序，排序之后局部最優(yōu)：每次合并都取最大的右邊界，這樣就可以合并更多的區(qū)間了，整體最優(yōu)：合并所有重疊的區(qū)間。

局部最優(yōu)可以推出全局最優(yōu)，找不出反例，試試貪心。

那有同學問了，本來不就應該合并最大右邊界么，這和貪心有啥關系?

有時候貪心就是常識!哈哈

按照左邊界從小到大排序之后，如果 intervals[i][0] < intervals[i - 1][1] 即intervals[i]左邊界 < intervals[i - 1]右邊界，則一定有重復，因為intervals[i]的左邊界一定是大于等于intervals[i - 1]的左邊界。

即：intervals[i]的左邊界在intervals[i - 1]左邊界和右邊界的范圍內，那么一定有重復!

這么說有點抽象，看圖：(注意圖中區(qū)間都是按照左邊界排序之后了)

合并區(qū)間

知道如何判斷重復之后，剩下的就是合并了，如何去模擬合并區(qū)間呢?

其實就是用合并區(qū)間后左邊界和右邊界，作為一個新的區(qū)間，加入到result數組里就可以了。如果沒有合并就把原區(qū)間加入到result數組。

C++代碼如下：

class Solution { 
public: 
    // 按照區(qū)間左邊界從小到大排序 
    static bool cmp (const vector<int>& a, const vector<int>& b) { 
        return a[0] < b[0]; 
    } 
    vector<vector<int>> merge(vector<vector<int>>& intervals) { 
        vector<vector<int>> result; 
        if (intervals.size() == 0) return result; 
        sort(intervals.begin(), intervals.end(), cmp); 
        bool flag = false; // 標記最后一個區(qū)間有沒有合并 
        int length = intervals.size(); 
 
        for (int i = 1; i < length; i++) { 
            int start = intervals[i - 1][0];    // 初始為i-1區(qū)間的左邊界 
            int end = intervals[i - 1][1];      // 初始i-1區(qū)間的右邊界 
            while (i < length && intervals[i][0] <= end) { // 合并區(qū)間 
                end = max(end, intervals[i][1]);    // 不斷更新右區(qū)間 
                if (i == length - 1) flag = true;   // 最后一個區(qū)間也合并了 
                i++;                                // 繼續(xù)合并下一個區(qū)間 
            } 
            // start和end是表示intervals[i - 1]的左邊界右邊界，所以最優(yōu)intervals[i]區(qū)間是否合并了要標記一下 
            result.push_back({start, end}); 
        } 
        // 如果最后一個區(qū)間沒有合并，將其加入result 
        if (flag == false) { 
            result.push_back({intervals[length - 1][0], intervals[length - 1][1]}); 
        } 
        return result; 
    } 
}; 

當然以上代碼有冗余一些，可以優(yōu)化一下，如下：(思路是一樣的)

class Solution { 
public: 
    vector<vector<int>> merge(vector<vector<int>>& intervals) { 
        vector<vector<int>> result; 
        if (intervals.size() == 0) return result; 
        // 排序的參數使用了lamda表達式 
        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b){return a[0] < b[0];}); 
 
        result.push_back(intervals[0]); 
        for (int i = 1; i < intervals.size(); i++) { 
            if (result.back()[1] >= intervals[i][0]) { // 合并區(qū)間 
                result.back()[1] = max(result.back()[1], intervals[i][1]); 
            } else { 
                result.push_back(intervals[i]); 
            } 
        } 
        return result; 
    } 
}; 

• 時間復雜度：O(nlogn) ，有一個快排
• 空間復雜度：O(1)，我沒有算result數組(返回值所需容器占的空間)

總結

對于貪心算法，很多同學都是：如果能憑常識直接做出來，就會感覺不到自己用了貪心, 一旦第一直覺想不出來, 可能就一直想不出來了。

跟著「代碼隨想錄」刷題的錄友應該感受過，貪心難起來，真的難。

那應該怎么辦呢?

正如我貪心系列開篇詞關于貪心算法，你該了解這些!中講解的一樣，貪心本來就沒有套路，也沒有框架，所以各種常規(guī)解法需要多接觸多練習，自然而然才會想到。

「代碼隨想錄」會把貪心常見的經典題目覆蓋到，大家只要認真學習打卡就可以了。

其他語言版本

Java

class Solution { 
    public int[][] merge(int[][] intervals) { 
        List<int[]> res = new LinkedList<>(); 
        Arrays.sort(intervals, (o1, o2) -> Integer.compare(o1[0], o2[0])); 
 
        int start = intervals[0][0]; 
        for (int i = 1; i < intervals.length; i++) { 
            if (intervals[i][0] > intervals[i - 1][1]) { 
                res.add(new int[]{start, intervals[i - 1][1]}); 
                start = intervals[i][0]; 
            } else { 
                intervals[i][1] = Math.max(intervals[i][1], intervals[i - 1][1]); 
            } 
        } 
        res.add(new int[]{start, intervals[intervals.length - 1][1]}); 
        return res.toArray(new int[res.size()][]); 
    } 
} 

// 版本2 
class Solution { 
    public int[][] merge(int[][] intervals) { 
        LinkedList<int[]> res = new LinkedList<>(); 
        Arrays.sort(intervals, (o1, o2) -> Integer.compare(o1[0], o2[0])); 
        res.add(intervals[0]); 
        for (int i = 1; i < intervals.length; i++) { 
            if (intervals[i][0] <= res.getLast()[1]) { 
                int start = res.getLast()[0]; 
                int end = Math.max(intervals[i][1], res.getLast()[1]); 
                res.removeLast(); 
                res.add(new int[]{start, end}); 
            } 
            else { 
                res.add(intervals[i]); 
            } 
        } 
        return res.toArray(new int[res.size()][]); 
    } 
} 

Python

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

Go

func merge(intervals [][]int) [][]int { 
    //先從小到大排序 
    sort.Slice(intervals,func(i,j int)bool{ 
        return intervals[i][0]<intervals[j][0] 
    }) 
    //再弄重復的 
    for i:=0;i<len(intervals)-1;i++{ 
        if intervals[i][1]>=intervals[i+1][0]{ 
            intervals[i][1]=max(intervals[i][1],intervals[i+1][1])//賦值最大值 
            intervals=append(intervals[:i+1],intervals[i+2:]...) 
            i-- 
        } 
    } 
    return intervals 
} 
func max(a,b int)int{ 
    if a>b{ 
        return a 
    } 
    return b 
} 

Javascript

var merge = function (intervals) { 
    intervals.sort((a, b) => a[0] - b[0]); 
    let prev = intervals[0] 
    let result = [] 
    for(let i =0; i<intervals.length; i++){ 
        let cur = intervals[i] 
        if(cur[0] > prev[1]){ 
            result.push(prev) 
            prev = cur 
        }else{ 
            prev[1] = Math.max(cur[1],prev[1]) 
        } 
    } 
    result.push(prev) 
    return result 
}; 

版本二：左右區(qū)間

/** 
 * @param {number[][]} intervals 
 * @return {number[][]} 
 */ 
var merge = function(intervals) { 
    let n = intervals.length; 
    if ( n < 2) return intervals; 
    intervals.sort((a, b) => a[0]- b[0]); 
    let res = [], 
        left = intervals[0][0], 
        right = intervals[0][1]; 
    for (let i = 1; i < n; i++) { 
        if (intervals[i][0] > right) { 
            res.push([left, right]); 
            left = intervals[i][0]; 
            right = intervals[i][1]; 
        } else { 
            right = Math.max(intervals[i][1], right); 
        } 
    } 
    res.push([left, right]); 
    return res; 
};