【Leet Code】56. Merge Intervals---Hard

Given a collection of intervals, merge all overlapping intervals.

For example,
Given [1,3],[2,6],[8,10],[15,18],

return [1,6],[8,10],[15,18].

思路：

刚看到这个题目没看懂什么意思，先对题目进行说明：

对以两个数对为元素的数组（或者其他结构）进行合并，并且该数组中的元素是以数对第一个值从小到大排序的（原题目没有排序，需要先对数组进行排序）。如果前面的数对a的第二个值>紧邻的后面的数对b的第一个值，则取两者中第一个值的最小值和第二个值的最大值组成一个新的数对c，删除数对a和b，将c作为新的元素存入结果中；否则将该数对a直接存入结果中。

以具体例子进行说明：

例1:

输入值： input＝[1,3],[2,6],[8,10],[15,18],

排序值： sortVal ＝ [1,3],[2,6],[8,10],[15,18],

操作：1）另下一个存入结果的数对mover ＝ ［1，3］

           2）循环处理剩下的每一个数对sortVal［i］，由于［2，6］数对中2小于mover的第二个值3，所以另mover ＝ ［1，6］

   3） mover中的6小于［8，10］中的8，将mover［2，6］存入结果，并另mover ＝ ［8， 10］

           4） mover中的10小于15，将mover［8， 10］存入结果，另mover＝ ［15， 18］

           5）循环已结束，将mover［15， 18］保存到结果

返回值：output＝[1,6],[8,10],[15,18]

例2:

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

Output:  [[0,5]]

同样的分析过程，此处不再具体分析。

实现算法：

1）对输入的vector进行排序，按照数对的第一个值从小到大的顺序；

2）从前向后遍历vector中的每个数对，如果数对a的end值小于于后面数对的begin值，将a数对存入结果，另a数对为当前数对的值；

否则将两者的end最大值作为新数对a的end值，继续循环。

代码实现：

/**
 * 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:
    vector<Interval> merge(vector<Interval>& intervals) {
        if (intervals.size() <= 1)  return intervals;
        int len = intervals.size();
        
        //如果不向破坏传进来的vector值，可以创建一个新的，以下对intervals的操作都换成对temp的操作即可
        //vector<Interval> temp = intervals;
        
        //排序vecotr，按照每个Interval元中的第一个元素从小到大的顺序
        std::sort(intervals.begin(), intervals.end(), [](Interval a, Interval b) {
        return a.start < b.start;   
        });
        

        // merge：
        // 如果mover的end值小于当前元素intervals[i]的start值，则直接将mover存入result，并另mover�指向当前元素；
        // 否则，另mover的end值 = mover.end和intervals[i].end的最大值
        vector<Interval> result;
        Interval mover = intervals[0];
        for (int i = 1; i < len; ++i) 
        {
            if (mover.end < intervals[i].start) 
            {
                result.push_back(mover);
                mover = intervals[i];
            } 
            else 
            {
                mover.end = max(mover.end, intervals[i].end);
            }
        }
        
        //将最后一个元素存入result中
        result.push_back(mover);
        return result;
    }
};