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]
.
First, this is not a problem about segment tree. Don't be hasty before you make decisions.
Second, the problem is how to sort. Give two ways in the following passage:
/**
* 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 cmp {
public:
bool operator()(Interval a, Interval b) {
return a.start == b.start?(a.end < b.end):(a.start < b.start);
}
};
class Solution {
public:
vector<Interval> merge(vector<Interval> &intervals) {
// Note: The Solution object is instantiated only once and is reused by each test case.
if (intervals.size() < 1)
return intervals;
vector<Interval> res;
sort(intervals.begin(), intervals.end(), cmp());
int i, j;
Interval cur(intervals[0].start, intervals[0].end);
for (i = 1; i < intervals.size(); ++i) {
if (intervals[i].start > cur.end) {
res.push_back(cur);
cur.start = intervals[i].start;
cur.end = intervals[i].end;
}
else
cur.end = max(intervals[i].end, cur.end);
}
res.push_back(cur);
return res;
}
};
/**
* 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 cmp {
public:
bool operator()(Interval a, Interval b) {
return a.start == b.start?(a.end < b.end):(a.start < b.start);
}
};
*/
bool operator<(Interval a, Interval b) {
return a.start == b.start?(a.end < b.end):(a.start < b.start);
}
class Solution {
public:
vector<Interval> merge(vector<Interval> &intervals) {
// Note: The Solution object is instantiated only once and is reused by each test case.
if (intervals.size() < 1)
return intervals;
vector<Interval> res;
sort(intervals.begin(), intervals.end());
int i, j;
Interval cur(intervals[0].start, intervals[0].end);
for (i = 1; i < intervals.size(); ++i) {
if (intervals[i].start > cur.end) {
res.push_back(cur);
cur.start = intervals[i].start;
cur.end = intervals[i].end;
}
else
cur.end = max(intervals[i].end, cur.end);
}
res.push_back(cur);
return res;
}
};
Python Version:
class Solution:
def cmp(self, lst):
return lst[0]
def merge(self, intervals):
res = []
intervals.sort(key=self.cmp, reverse=False)
ilen = len(intervals)
if (intervals):
cur = [intervals[0][0], intervals[0][1]]
for i in range(1, ilen):
if (intervals[i][0] <= cur[1]):
cur[1] = max(intervals[i][1], cur[1])
else:
res.append(cur)
cur=[intervals[i][0],intervals[i][1]]
res.append(cur)
return res
--------------------------------------------------------------------------------------------------------------
We are given a list schedule
of employees, which represents the working time for each employee.
Each employee has a list of non-overlapping Intervals
, and these intervals are in sorted order.
Return the list of finite intervals representing common, positive-length free time for all employees, also in sorted order.
(Even though we are representing Intervals
in the form [x, y]
, the objects inside are Intervals
, not lists or arrays. For example, schedule[0][0].start = 1
, schedule[0][0].end = 2
, and schedule[0][0][0]
is not defined). Also, we wouldn't include intervals like [5, 5] in our answer, as they have zero length.
Example 1:
Input: schedule = [[[1,2],[5,6]],[[1,3]],[[4,10]]] Output: [[3,4]] Explanation: There are a total of three employees, and all common free time intervals would be [-inf, 1], [3, 4], [10, inf]. We discard any intervals that contain inf as they aren't finite.
Example 2:
Input: schedule = [[[1,3],[6,7]],[[2,4]],[[2,5],[9,12]]] Output: [[5,6],[7,9]]
Constraints:
1 <= schedule.length , schedule[i].length <= 50
0 <= schedule[i].start < schedule[i].end <= 10^8
"""
# Definition for an Interval.
class Interval:
def __init__(self, start: int = None, end: int = None):
self.start = start
self.end = end
"""
class Solution:
def employeeFreeTime(self, schedule: '[[Interval]]') -> '[Interval]':
candidates,res = [],[]
for employee in schedule:
for inter in employee:
candidates.append([inter.start,inter.end]) #bug2: candidates.append((inter.start,inter.end))
candidates.sort()
l = len(candidates)
merged = [candidates[0]]
for i in range(1,l):
cur,top = candidates[i],merged[-1]
if (cur[0] <= top[1]):
merged[-1][1] = max(cur[1],merged[-1][1]) #bug1: merged[-1][1] = cur[1]
else:
merged.append(cur)
ml = len(merged)
if (ml == 1):
return res
for i in range(1,ml):
res.append(Interval(merged[i-1][1],merged[i][0]))
return res