[LeetCode] 253. Meeting Rooms II 会议室 II

Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei), find the minimum number of conference rooms required.

For example,
Given [[0, 30],[5, 10],[15, 20]],
return 2.

252. Meeting Rooms 的拓展，同样给一个开会的区间数组，返回最少需要的房间数。

解法1: 把区间变成2个数组：start时间数组和end时间数组，并对两个数组排序。然后一个指针遍历start数组，另一个指针指向end数组。如果start时间小于end时间，房间数就加1，start时间加1，比较并记录出现过的最多房间数。start时间大于end，则所需房间数就减1，end指针加1。

解法2：最小堆minHeap，先按start排序，然后维护一个minHeap，堆顶元素是会议结束时间最早的区间，也就是end最小。每次比较top元素的end时间和当前元素的start时间，如果end < start，说明该room可以结束接下来被当前会议区间使用。最后返回堆的大小就是所需的房间数。

面试follow up: 结果要将会议名称跟对应房间号一起返回，而不仅仅是算需要的房间数目。

Java：

/** 
 * Definition for an interval. 
 * public class Interval { 
 *     int start; 
 *     int end; 
 *     Interval() { start = 0; end = 0; } 
 *     Interval(int s, int e) { start = s; end = e; } 
 * } 
 */ 
public class Solution {  
    public int minMeetingRooms(Interval[] intervals) {  
        if(intervals == null || intervals.length == 0) return 0;  
        int min = 0; int max = 0;  
        for(int i=0; i<intervals.length; i++){  
            min = Math.min(min, intervals[i].start);  
            max = Math.max(max, intervals[i].end);  
        }  
           
        int[] count = new int[max-min+1];  
        for(int i=0; i<intervals.length; i++){  
            count[intervals[i].start]++;  
            count[intervals[i].end]--;  
        }  
        int maxroom = Integer.MIN_VALUE;  
        int num = 0;  
        for(int i=0; i<count.length; i++){  
            num += count[i];  
            maxroom = Math.max(maxroom, num);  
        }  
        return maxroom;  
    }  
}  　　

Java：minHeap

public class Solution { 
   public int minMeetingRooms(Interval[] intervals) {    
     int n=intervals.length;    
     Arrays.sort(intervals, new Comparator<Interval>(){  
         public int compare(Interval a, Interval b) {    
           return a.start-b.start;    
         }  
     });    
     PriorityQueue<Integer> pq=new PriorityQueue<>();    
     for (int i=0; i<n; i++) {    
       if (i>0 && intervals[i].start>=pq.peek()) pq.poll();    
       pq.add(intervals[i].end);    
     }    
     return pq.size();    
   }    
 }    　　

Python:

class Solution:
    # @param {Interval[]} intervals
    # @return {integer}
    def minMeetingRooms(self, intervals):
        starts, ends = [], []
        for i in intervals:
            starts.append(i.start)
            ends.append(i.end)
 
        starts.sort()
        ends.sort()
 
        s, e = 0, 0
        min_rooms, cnt_rooms = 0, 0
        while s < len(starts):
            if starts[s] < ends[e]:
                cnt_rooms += 1  # Acquire a room.
                # Update the min number of rooms.
                min_rooms = max(min_rooms, cnt_rooms)
                s += 1
            else:
                cnt_rooms -= 1  # Release a room.
                e += 1
 
        return min_rooms

C++:

class Solution {
public:
    int minMeetingRooms(vector<Interval>& intervals) {
        vector<int> starts, ends;
        for (const auto& i : intervals) {
            starts.emplace_back(i.start);
            ends.emplace_back(i.end);
        }
         
        sort(starts.begin(), starts.end());
        sort(ends.begin(), ends.end());
         
        int min_rooms = 0, cnt_rooms = 0;
        int s = 0, e = 0;
        while (s < starts.size()) {
            if (starts[s] < ends[e]) {
                ++cnt_rooms;  // Acquire a room.
                // Update the min number of rooms.
                min_rooms = max(min_rooms, cnt_rooms);
                ++s;
            } else {
                --cnt_rooms;  // Release a room.
                ++e;
            }
        }
        return min_rooms;
    }
};

C++: minHeap

class Solution {
public:
    int minMeetingRooms(vector<Interval>& intervals) {
        sort(intervals.begin(), intervals.end(), [](const Interval &a, const Interval &b){return a.start < b.start;});
        priority_queue<int, vector<int>, greater<int>> q;
        for (auto a : intervals) {
            if (!q.empty() && q.top() <= a.start) q.pop();
            q.push(a.end);
        }
        return q.size();
    }
};