leetcode 56. Merge Intervals 759. Employee Free Time 不用线段树

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