Merge interval series:

• for (int i = 1; ) not 0
• use last = intervals[0]

number of airplanes in the sky

• turn on and turn off, then count total turned-on
• be careful the comparator, when interval time equals, flag off comes first then flag on

class Point {
    int time;
    int flag;

    Point(int time, int flag) {
        this.time = time;
        this.flag = flag;
    }
}

class Solution {
    public int countOfAirplanes(List<Interval> airplanes) { 
        List<Point> list = new ArrayList<>();
        for (Interval interval : airplanes) {
            list.add(new Point(interval.start, 1));
            list.add(new Point(interval.end, 0));
        }

        Collections.sort(list, (p1, p2) -> {
            if (p1.time != p2.time) {
                return p1.time - p2.time;
            } else {
                return p1.flag - p2.flag;
            }
        });

        int ans = 0;
        int count = 0;

        for (Point p : list) {
            if (p.flag == 1) 
                count++;
            else
                count--;
            ans = Math.max(ans, count);
        }
        return ans;
    }
}

build outline

??

merge interval

//?? use bitset??

class Solution {
    public List<Interval> merge(List<Interval> intervals) {

        if (intervals.size() <= 1) return intervals;

        List<Interval> rst = new ArrayList<>();

        intervals.sort((i1, i2) -> Integer.compare(i1.start, i2.start));

        int start = intervals.get(0).start;
        int end = intervals.get(0).end;

        // 1. disjoint: add and reset bound
        // 2. overlapping: merge 
        for (Interval interval : intervals) {            
            if (end < interval.start) {
                rst.add(new Interval(start, end));
                start = interval.start;
                end = interval.end;                
            } else {
                //start = Math.min(interval.start, start);
                end = Math.max(interval.end, end);
            }
        }        
        rst.add(new Interval(start, end));

        return rst;        
    }
}

insert interval

public class Solution {
    public List<Interval> insert(List<Interval> intervals, Interval newInterval) {

        if (intervals == null || newInterval == null) {
            return intervals;
        }

        ArrayList<Interval> result = new ArrayList<>();
        int start = newInterval.start;
        int end = newInterval.end;

        // treat newInsert as starting point
        // one more case to consider comparing to Merge Interval:
        // curr interval happens before starting point (newInsert)
        for (Interval interval : intervals) {
            if (interval.end < start) {
                result.add(interval);
            } else if (end < interval.start) {
                result.add(new Interval(start, end));
                start = interval.start;
                end = interval.end;                
            } else {
                start = Math.min(interval.start, start);
                end = Math.max(interval.end, end);
            }                     
        }

        result.add(new Interval(start, end));
        return result;
    }        
}