[LeetCode] 253. Meeting Rooms II
Given an array of meeting time intervals intervals
where intervals[i] = [starti, endi]
, return the minimum number of conference rooms required.
Example 1:
Input: intervals = [[0,30],[5,10],[15,20]] Output: 2
Example 2:
Input: intervals = [[7,10],[2,4]] Output: 1
Constraints:
1 <= intervals.length <= 104
0 <= starti < endi <= 106
会议室二。
给你一个会议时间安排的数组 intervals ,每个会议时间都会包括开始和结束的时间 intervals[i] = [starti, endi] ,返回 所需会议室的最小数量 。
来源:力扣(LeetCode)
链接:https://leetcode.cn/problems/meeting-rooms-ii
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。
- 两种思路,我这里分享一个官方题解,有图示帮助理解。
- 这里我再提供一个labuladong的题解,思路跟官方题解一样。
第一种是排序 + 双指针。具体做法是把每个会议的开始时间和结束时间拎出来分别排序,再遍历 intervals。遍历的时候,设置一个 pointer = 0,判断当前 interval[i] 的开始时间是否大于前一个会议的结束时间 interval[pointer][end]。如果大于,就说明不需要新开一个会议室;如果小于,就需要新开一个会议室。因为题目只在意需要同时开几个会议室,所以 start 和 end 可以分别排序。end 只要结束一个,就意味着同时需要的会议室就少一个。
如果扫描线的题目做多了,一开始的本能反应可能是对 start 或者对 end 排序,看看是否存在 interval 之间的 overlap,但是其实是行不通的,因为可能存在比如某个会议 start 时间没有跟其他任何一个会议的 end 时间有冲突,但是有可能这个会议一直持续到最后,他的 end 时间跟别的会议也没有 overlap,但是他其实一直是占用一个房间的。
同时,为什么排序+双指针这个做法是正确的呢?对 start 和对 end 分别排序之后,因为 start 和 end 是有序的,在用双指针分别指向当前的 start 和当前的 end 的时候,只要当前 start 小于当前的 end,就一定要再开一个房间,因为当前确实是有一个会议没有结束。我们将 start 和 end 分别排序之后,其实是可以把数据抽象成如下这幅图的(引用)。
所以只要碰到 start,就一定要增加一个房间,碰到 end 就可以减少一个房间。我们在遍历的过程中找到同时使用的会议室的峰值即可。
时间O(nlogn) - 因为有对input排序
空间O(n) - 有用额外数组对start和end排序
JavaScript实现
1 /** 2 * @param {number[][]} intervals 3 * @return {number} 4 */ 5 var minMeetingRooms = function(intervals) { 6 let start = []; 7 let end = []; 8 let len = intervals.length; 9 for (let i = 0; i < len; i++) { 10 let cur = intervals[i]; 11 start.push(cur[0]); 12 end.push(cur[1]); 13 } 14 start = start.sort((a, b) => a - b); 15 end = end.sort((a, b) => a - b); 16 let res = 0; 17 let pointer = 0; 18 for (let i = 0; i < len; i++) { 19 if (start[i] < end[pointer]) { 20 res++; 21 } else { 22 pointer++; 23 } 24 } 25 return res; 26 };
Java实现
1 class Solution { 2 public int minMeetingRooms(int[][] intervals) { 3 // corner case 4 if (intervals == null || intervals.length == 0) { 5 return 0; 6 } 7 // normal case 8 int len = intervals.length; 9 int[] start = new int[len]; 10 int[] end = new int[len]; 11 for (int i = 0; i < len; i++) { 12 start[i] = intervals[i][0]; 13 end[i] = intervals[i][1]; 14 } 15 Arrays.sort(start); 16 Arrays.sort(end); 17 int res = 0; 18 int pointer = 0; 19 for (int i = 0; i < len; i++) { 20 if (start[i] < end[pointer]) { 21 res++; 22 } else { 23 pointer++; 24 } 25 } 26 return res; 27 } 28 }
[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)
1 class Solution { 2 public int minMeetingRooms(int[][] intervals) { 3 // corner case 4 if (intervals == null || intervals.length == 0) { 5 return 0; 6 } 7 8 // normal case 9 Arrays.sort(intervals, (a, b) -> a[0] - b[0]); 10 // sort by ending time 11 PriorityQueue<int[]> heap = new PriorityQueue<>(intervals.length, (a, b) -> a[1] - b[1]); 12 heap.offer(intervals[0]); 13 for (int i = 1; i < intervals.length; i++) { 14 int[] now = heap.poll(); 15 if (intervals[i][0] >= now[1]) { 16 now[1] = intervals[i][1]; 17 } else { 18 heap.offer(intervals[i]); 19 } 20 heap.offer(now); 21 } 22 return heap.size(); 23 } 24 }