# LeetCode – Meeting Rooms II (Java)

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

Java Solution
When a room is taken, the room can not be used for anther meeting until the current meeting is over. As soon as the current meeting is finished, the room can be used for another meeting. We can sort the meetings by start timestamps and sequentially assign each meeting to a room. Each time when we assign a room for a meeting, we check if any meeting is finished so that the room can be reused. In order to efficiently track the earliest ending meeting, we can use a min heap. Whenever an old meeting ends before a new meeting starts, we reuse the room (i.e., do not add more room). Otherwise, we need an extra room (i.e., add a room).

The time complexity is O(N*log(N)).

```public int minMeetingRooms(int[][] intervals) { Arrays.sort(intervals, Comparator.comparing((int[] itv) -> itv[0]));   PriorityQueue<Integer> heap = new PriorityQueue<>(); int count = 0; for (int[] itv : intervals) { if (heap.isEmpty()) { count++; heap.offer(itv[1]); } else { if (itv[0] >= heap.peek()) { heap.poll(); } else { count++; }   heap.offer(itv[1]); } }   return count; }```

There was a discussion in the comments about why a regular queue is not good enough. I draw an example below to show why sorting based on start time and using a priority queue is necessary.

Category >> Algorithms
If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:
```<pre><code>
String foo = "bar";
</code></pre>
```
• Srinath Shetty

Not working for below case
[[6,15],[13,20],[6,17]]
Expected: 3
OP: 1

• Nitin Sridhar

//Program is similar to this but start and end meeting time are in different arrays
// Program to find minimum number of rooms

import java.util.*;

class MeetingRoom {

// Returns minimum number of rooms required
static int findMeetingRooms(int arr[], int dep[], int n)
{
// Sort start and departure arrays
Arrays.sort(arr);
Arrays.sort(dep);

// room_needed indicates number of rooms
// needed at a time
int room_needed = 1, result = 1;
int i = 1, j = 0;

// Similar to merge in merge sort to process
// all events in sorted order
while (i < n && j < n)
{
// If next event in sorted order is start time,
// increment count of rooms needed
if (arr[i] result)
result = room_needed;
}

// Else decrement count of rooms needed
else
{
room_needed–;
j++;
}
}

return result;
}

// Driver program to test methods of graph class
public static void main(String[] args)
{
int arr[] = {900, 940, 950, 1100, 1500, 1800};
int dep[] = {910, 1200, 1120, 1130, 1900, 2000};
int n = arr.length;
System.out.println(“Minimum Number of Rooms Required = ”
+ findMeetingRooms(arr, dep, n));
}
}

• Sudeep S-r

Why can’t we follow meeting room one soln ? like if there is an overlap then inc count then no extra space is required

• Dinh Nhat

Hey, thanks for a detailed solution.
Can you also explain how did you come up with this solution? thanks.

• Cat Racket

A JavaScript Solution:
Chinese: https://youtu.be/uEGNNeiMxuI
English: https://youtu.be/24li7yc91us

• Pooja Gupta

It is showing extra count

• Prashant Nigam

What would be the runtime (big O) of your approach?

• Prashant Nigam

You don’t require a counter, heap size at the end is the required number of rooms

• It is fine. Output is one meeting room.

• santosh sunny

Hi , i got a doubt. Whenever we are taking a new interval, instead of comparing with the smallest ending times why can’t we start comparing from largest of the finished ending times until we get a ending time which is smaller than current interval start time .
Example : priority Queue : {13,16}
Current interval : [17,21]
If we choose 16 -> priority queue :{16,17}
So here instead of 13 if we choose 16 -> priority queue : {13,17}
Isn’t the second case better than first one as it will give less collisions compared to first one.

• Bonsai

I don’t think your solution is right. Try this example [[7,10],[2,4]]

• Satish

``` public static int meetingRooms(Interval[] intervals) { if (intervals.length == 0) { return 0; } // Sort start of interval in ascending order Arrays.sort(intervals, new Comparator() { public int compare(Interval o1, Interval o2) { return o1.start - o2.start; } }); int result = intervals.length; // Worst case all room will need its own room for (int i = 0; i = intervals[i + 1].start // curr overlap with next || (intervals[i].start >= intervals[i + 1].start && intervals[i].end <= intervals[i + 1].end) // curr completely overlap with next ) { result--; } } return result; } ```

• Amit

why wont it?
It will work.

First 10-16 is compared with 11-13… count is incremented
then 11-13 is added to priority queue..
then 11-13 is compared with 14-17… count is NOT incremented.

Result: 2

• rohit

this will not work for 10-16,11-13,14-17

• Ankit Shah
• Ankur

Instead of Priority Queue take simple queue to store elements but just sort by endTime .

``` private static int minMeetingRoomsQueue(Interval[] inte) { int c = 0; Arrays.sort(inte,new Comparator(){```

``` @Override public int compare(Interval o1, Interval o2) { return o1.eTime - o2.eTime; } ```

``` }); Queue q = new LinkedList(); q.add(inte[0].eTime); c++; for(int i=1;i<inte.length;i++){ if(inte[i].sTime < q.peek()){ c++; }else{ q.poll(); } q.add(inte[i].eTime); } return c; } ```