leetcode #56 in cpp

最新推荐文章于 2024-09-21 10:02:17 发布

xiaolienahu

最新推荐文章于 2024-09-21 10:02:17 发布

阅读量130

点赞数

分类专栏： interview 文章标签： cpp leetcode

本文链接：https://blog.csdn.net/xiaolienahu/article/details/51535144

版权

interview 专栏收录该内容

135 篇文章 0 订阅

订阅专栏

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].

Solution 1: O(n^2)

Code:

/**
 * 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) {
       vector<Interval> I;
       if(intervals.empty()) return I;
       
       vector<bool> merged(intervals.size(),false);//denote which interval has been merged
       int push_ind = 0;// denote which interval we are going to merge with other intervals. And it denotes which interval we would push into I after merging
       
       while(push_ind < intervals.size()){
           int has_new_interval = 0; //denote if interval[push_ind] is merged with some and get updated. If in last iterations                      //it does not merge with any intervals, we are done check it and should push it into I.  
           for(int i = push_ind + 1; i < intervals.size(); i ++){//find other interval to merge 
               if(merged[i]) continue;//if intervals[i] has been merged, continue
               if(isOverlapping(intervals[push_ind], intervals[i])){//check if they are overlapping, if so
                   //merge two intervals into one
                   intervals[push_ind].start = min(intervals[push_ind].start, intervals[i].start);
                   intervals[push_ind].end = max(intervals[push_ind].end, intervals[i].end);
                   merged[i] = true;//denote the intervals[i] has been merged
                   has_new_interval = 1;//denote that interval[push_ind] is updated
               }
               
           }
           if(!has_new_interval){//when interval[push_ind] cannot be updated, interval[push_ind] is disjoint from other intervals, we push this interval with push_ind
               I.push_back(intervals[push_ind]);
               merged[push_ind] = true; //denote the interval has been merged
               while(push_ind<intervals.size()){
                   if(!merged[push_ind]) break;
                   push_ind++;
               }
           }
       }
       
       
       
       
       return I;
       
    }
    bool isOverlapping(Interval front, Interval back){
        //make front has the smaller start
        if(front.start > back.start){
            swap(front.start, back.start);
            swap(front.end,back.end);
        }
        return front.end >= back.start;
    }
};

Solution 2: O(nlgn)
Code:

/**
 * 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:
 struct Comp{
        bool operator()(Interval i1,Interval i2)
        {
            return i1.start<i2.start;
        }
    };

    vector<Interval> merge(vector<Interval>& intervals) {
       vector<Interval> I;
       if(intervals.empty()) return I;
       sort(intervals.begin(), intervals.end(),Comp());
       while(!intervals.empty()){
           if(intervals.size() == 1){
               I.push_back(intervals[0]);
               break;
           }else{
                while(intervals.size() >1 && intervals[0].end >= intervals[1].start){//merge
                    intervals[0].start = min(intervals[0].start, intervals[1].start);
                    intervals[0].end = max(intervals[0].end, intervals[1].end);
                    intervals.erase(intervals.begin() + 1);
                }
                I.push_back(intervals[0]);
                intervals.erase(intervals.begin());
           }
           
       }
       return I;
       
    }
    
};