[leetcode] Merge Intervals

题目

Given a collection of intervals, merge all overlapping intervals.

---

Example 1:
Input: [[1,3],[2,6],[8,10],[15,18]]
Output: [[1,6],[8,10],[15,18]]
Explanation: Since intervals [1,3] and [2,6] overlaps, merge them into [1,6].

---

Example 2:
Input: [[1,4],[4,5]]
Output: [[1,5]]
Explanation: Intervals [1,4] and [4,5] are considerred overlapping.

$O(n^2)$解法

思路

我们把所有区间分成两个集合，集合intervals中存放尚未处理完成的区间，集合res中存放已处理完成的区间。其中“已处理完成”的含义为：res中任意一个区间与intervals中所有区间均不相交。
我们的算法为：

1. 从intervals中任取一个区间，并把这个区间与其他所有区间比较，若相交，转2，若和所有区间都不相交，转3
2. 合并这两个区间，并把新区间放回intervals。转4
3. 把所选区间放入res。转4
4. 若intervals仍然有元素，转1
5. 返回res
   容易分析，123循环一趟的复杂度为$O(n)$，循环的趟数为$O(n)$，总复杂度为$O(n^2)$

代码

class Solution {
public:
  vector<Interval> merge(vector<Interval>& intervals) {
    vector<Interval> res;
    while(!intervals.empty()) {
      bool hasMerge = false;
      // 可以融合
      for(int i=1; i!=intervals.size(); ++i) {
        if(_overlap(intervals[0], intervals[i])) {
          intervals[0] = _merge(intervals[0], intervals[i]);
          for(int j=i; j<intervals.size(); ++j) {
            intervals[j] = intervals[j+1];
          }
          intervals.pop_back();
          hasMerge = true;
          break;
        }
      }
      if(!hasMerge) {
        res.push_back(intervals.front());
        for(int j=0; j<intervals.size(); ++j) {
          intervals[j] = intervals[j+1];
        }
        intervals.pop_back();
      }
    }
    return res;
  }
private:
  bool _overlap(Interval& i1, Interval& i2) {
    return !(i1.start > i2.end || i2.start > i1.end);
  }
  Interval _merge(Interval& i1, Interval& i2) {
    return Interval(
      i1.start < i2.start ? i1.start : i2.start,
      i1.end > i2.end ? i1.end : i2.end
    );
  }
};

$O(nlogn)$解法

思路

我们把区间的端点分为两类：左端点和右端点。注意到，如果多个区间可以合并，那么必然是左右端点的大小顺序一定满足一种栈的结构：把左端点看作入栈，右端点看作出栈，那么若干个区间经过入栈出栈操作之后，如果栈为空，那么说明这几个区间可以合并。
这个算法的一个关键在于，需要让左端点按从小到大的顺序出现。而这也是算法复杂度的主要来源。对n个区间的左端点进行排序的时间复杂度为$O(nlogn)$
（算法参考）

代码

const int BEGINNING = 0;
const int ENDING = 1;

struct Event {
	int time;
	int type;
	Event() {}
	Event(int time, int type) : time(time), type(type) {}
};

bool operator < (const Event &evA, const Event &evB) {
	if (evA.time != evB.time) {
		return evA.time < evB.time;
	}
	return evA.type < evB.type;
}

class Solution {
public:
	vector<Interval> merge(vector<Interval>& intervals) {
		vector<Event> events;
		for (Interval interval:intervals) {
			events.push_back(
				Event(interval.start, BEGINNING)
			);
			events.push_back(
				Event(interval.end, ENDING)
			);
		}
	
		sort(events.begin(), events.end());
		vector<Interval> compresedIntervals;
		int activeLines = 0;
		int lastBeginning = -1;
		for (Event event:events) {
			if (event.type == BEGINNING) {
				activeLines ++;
				if (activeLines == 1) {
					lastBeginning = event.time;
				}
			} else {
				activeLines --;
				if (activeLines == 0) {
					compresedIntervals.push_back(
						Interval(lastBeginning, event.time)
					);
				}
			}
		}
		return compresedIntervals;
	}
};