[LintCode] Number of Airplanes in the Sky

Given an interval list which are flying and landing time of the flight. How many airplanes are on the sky at most?

If landing and flying happens at the same time, we consider landing should happen at first.

Example

For interval list

[
  [1,10],
  [2,3],
  [5,8],
  [4,7]
]

Return 3

This problem is a classical example of applying sweep-line algorithm. Typically each interval represents one event, 

the start of an interval represents the beginning of an event and the end of the interval represents the finish of the

same event. In this problem, interval's start means one airplane takes off; interval's end means the same airplane lands.

Algorithm: 

1. save flying times and landing time separately and sort them in ascending order.

2. Iterate through all flying times and do the following. (only flying time may give us more airplanes in the sky)

　a. If the current earliest flying time is smaller than the current earliest landing time, we know we have 1 more 

　　plane flying, 0 more plane landing.  Increment current number of planes in the sky by 1 and set current fly time 

　　to the next earliest time.

　b. else, we know we have 1 more plane landing, 0 more plane flying, Decrement current number of planes in the sky

　　by 1 and set current land time to the next earliest time.

　c. After processing the current flying time of either case a or b, update the max number.

Special case to consider: What about if one plane flys and another plane lands at the same time? Does the above algorithm 

still work?

When starts[startIdx] == ends[endIdx],  the above algorithm consider it as 1 plane landing, so curr--, endIdx++; 

But startIdx is not changed and the while loop exit condition is startIdx >= n, so we'll still process this fly time in the next iteration. 

It will always be processed as the latest landing time must be the biggest number of all. So for each new fly time, case a always 

hold once. This proves the above algorithm works for this special case, it even works for cases where we have multiple planes 

fly or land at the same time.

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 */

class Solution {
    /**
     * @param intervals: An interval array
     * @return: Count of airplanes are in the sky.
     */
    public int countOfAirplanes(List<Interval> airplanes) { 
        if(airplanes == null) {
            return 0;    
        }    
        if(airplanes.size() <= 1) {
            return airplanes.size();
        }
        int n = airplanes.size();
        int[] starts = new int[n];
        int[] ends = new int[n];
        for(int i = 0; i < n; i++){
            starts[i] = airplanes.get(i).start;
            ends[i] = airplanes.get(i).end;
        }
        Arrays.sort(starts);
        Arrays.sort(ends);
        int startIdx = 0, endIdx = 0, curr = 0, max = 0;
        while(startIdx < n){
            if(starts[startIdx] < ends[endIdx]){
                curr++;
                startIdx++;
            }
            else{
                curr--;
                endIdx++;
            }
            max = Math.max(max, curr);
        }
        return max;
    }
}

Related Problems 

Merge Intervals