题目
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 ) O(n^2) O(n2)解法
思路
我们把所有区间分成两个集合,集合intervals中存放尚未处理完成的区间,集合res中存放已处理完成的区间。其中“已处理完成”的含义为:res中任意一个区间与intervals中所有区间均不相交。
我们的算法为:
- 从intervals中任取一个区间,并把这个区间与其他所有区间比较,若相交,转2,若和所有区间都不相交,转3
- 合并这两个区间,并把新区间放回intervals。转4
- 把所选区间放入res。转4
- 若intervals仍然有元素,转1
- 返回res
容易分析,123循环一趟的复杂度为 O ( n ) O(n) O(n),循环的趟数为 O ( n ) O(n) O(n),总复杂度为 O ( n 2 ) O(n^2) O(n2)
代码
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 ( n l o g n ) O(nlogn) O(nlogn)解法
思路
我们把区间的端点分为两类:左端点和右端点。注意到,如果多个区间可以合并,那么必然是左右端点的大小顺序一定满足一种栈的结构:把左端点看作入栈,右端点看作出栈,那么若干个区间经过入栈出栈操作之后,如果栈为空,那么说明这几个区间可以合并。
这个算法的一个关键在于,需要让左端点按从小到大的顺序出现。而这也是算法复杂度的主要来源。对n个区间的左端点进行排序的时间复杂度为
O
(
n
l
o
g
n
)
O(nlogn)
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;
}
};