[Leetcode] 253. Meeting Rooms II

Problems: https://leetcode.com/problems/meeting-rooms-ii/

Solution1:
首先对不同intervals根据开始时间进行排序，再利用priority queue存储不同rooms的结束时间；
（* priority queue只能帮助确定peek是最小（或最大）值，queue内其他元素排序未知）
对不同的intervals和peek进行比较，若peek值小，即该房间已经available，移出peek值
将下一个intervals的end time插入，注意无论peek是否被移出，都需要插入（插入后priority queue会根据end time自动重排）

class Solution {
    public int minMeetingRooms(int[][] intervals) {
        // 升序，PriorityQueue只能保证peek是最小（或最大），其余元素排序状态未知
        PriorityQueue<Integer> rooms = new PriorityQueue<>((p, q) -> p-q); 
        if(intervals.length == 0) {
            return 0;
        }
        
        Arrays.sort(intervals, (a,b) -> a[0]-b[0]);// 按照开始时间的早晚进行排序
        rooms.add(intervals[0][1]);
        
        for(int i=1; i<intervals.length; i++) {
            // 寻找最早结束的room，若room available则移出原有的时间
            if(intervals[i][0] >= rooms.peek()) {
                rooms.poll();
            }
            
            // 不论是否移出，新的event都要被加入
            rooms.add(intervals[i][1]);
        }
        
        return rooms.size();
    }
}

priority queue实现了mini heap，mini heap的算法复杂度为O(logn)，整个程序的时间复杂度为O(nlogn)。

Solution2:
将start time和end time分别对待（很绝）

class Solution {
    public int minMeetingRooms(int[][] intervals) {
        int len = intervals.length;
        int[] start = new int[len];
        int[] end = new int[len];
        
        for(int i=0; i<len; i++) {
            start[i] = intervals[i][0];
            end[i] = intervals[i][1];
        }
        
        //妙点：分开sort开始点和结束点，即拆开开始和结束之间的联系，并不影响结果
        //因为只需要找到最早结束的end时间即可
        Arrays.sort(start);
        Arrays.sort(end);
        
        int endPoint = 0;
        int room = 0;
        for(int startPoint=0; startPoint<len; startPoint++) {
            if(start[startPoint] < end[endPoint]) {
                room++;
            } else {
                endPoint++;
            }
        }
        return room;
    }
}