[LeetCode] 253. Meeting Rooms 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.

Example 1:

Input: [[0, 30],[5, 10],[15, 20]]
Output: 2

Example 2:

Input: [[7,10],[2,4]]
Output: 1

NOTE: input types have been changed on April 15, 2019. Please reset to default code definition to get new method signature.

会议室二。

版本一问的是一个人是否有可能参与所有的会议，版本二问的是给一堆会议的起止时间，问需要多少个会议室。

两种思路，我这里分享一个官方题解，有图示帮助理解。第一种是把每个会议的开始时间和结束时间拎出来分别排序，再遍历intervals。遍历的时候，设置一个pointer = 0，判断当前interval[i]的开始时间是否大于前一个会议的结束时间interval[pointer][end]。如果大于，就说明不需要新开一个会议室；如果小于，就需要新开一个会议室。因为题目只在意需要同时开几个会议室，所以start和end可以分别排序。end只要结束一个，就意味着同时需要的会议室就少一个。

时间O(nlogn) - 因为有对input排序

空间O(n) - 有用额外数组对start和end排序

JavaScript实现

/**
 * @param {number[][]} intervals
 * @return {number}
 */
var minMeetingRooms = function(intervals) {
    let start = [];
    let end = [];
    let len = intervals.length;
    for (let i = 0; i < len; i++) {
        let cur = intervals[i];
        start.push(cur[0]);
        end.push(cur[1]);
    }
    start = start.sort((a, b) => a - b);
    end = end.sort((a, b) => a - b);
    let res = 0;
    let pointer = 0;
    for (let i = 0; i < len; i++) {
        if (start[i] < end[pointer]) {
            res++;
        } else {
            pointer++;
        }
    }
    return res;
};

Java实现

class Solution {
    public int minMeetingRooms(int[][] intervals) {
        // corner case
        if (intervals == null || intervals.length == 0) {
            return 0;
        }
        // normal case
        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];
        }
        Arrays.sort(start);
        Arrays.sort(end);
        int res = 0;
        int pointer = 0;
        for (int i = 0; i < len; i++) {
            if (start[i] < end[pointer]) {
                res++;
            } else {
                pointer++;
            }
        }
        return res;
    }
}

[Java only] 第二种思路

先对intervals按开始时间排序，再用一个最小堆存放每个interval的结束时间，并加入第一个interval，此时堆顶是第一个interval的结束时间。遍历intervals，判断当前interval的开始时间（A）跟堆顶interval的结束时间（B），若A >= B则说明两个interval没有overlap，extend堆顶interval的结束时间；若A < B则将当前interval放入堆中。

时间O(nlogn)，其中排序O(nlogn)，heap的各项操作O(logn)

空间O(n)

class Solution {
    public int minMeetingRooms(int[][] intervals) {
        // corner case
        if (intervals == null || intervals.length == 0) {
            return 0;
        }

        // normal case
        Arrays.sort(intervals, (a, b) -> a[0] - b[0]);
        // sort by ending time
        PriorityQueue<int[]> heap = new PriorityQueue<>(intervals.length, (a, b) -> a[1] - b[1]);
        heap.offer(intervals[0]);
        for (int i = 1; i < intervals.length; i++) {
            int[] now = heap.poll();
            if (intervals[i][0] >= now[1]) {
                now[1] = intervals[i][1];
            } else {
                heap.offer(intervals[i]);
            }
            heap.offer(now);
        }
        return heap.size();
    }
}

扫描线相关题目

LeetCode 题目总结