253_Meeting_Rooms_II

Author: qiyuangong

README.md

@@ -91,6 +91,7 @@ Also, there are open source implementations for basic data structs and algorithm
 | 246 | [Strobogrammatic Number](https://leetcode.com/problems/strobogrammatic-number/) ♥ | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/246_Strobogrammatic_Number.py) | Hash table and reverse string, O(n) and O(n) |
 | 249 | [Group Shifted Strings](https://leetcode.com/problems/group-shifted-strings/) ♥ | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/249_Group_Shifted_Strings.py) | Hash and generate hash code for each string, O(n) and O(n) |
 | 252 | [Meeting Rooms](https://leetcode.com/problems/meeting-rooms/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/252_Meeting_Rooms.py) | 1. Sort and compare intervals[i].end with intervals[i+1], O(nlogn) and O(1)<br>2. Sort and check intervals when count >= 2, O(nlogn) and O(n) |
+| 253 | [Meeting Rooms II](https://leetcode.com/problems/meeting-rooms-ii/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/253_Meeting_Rooms_II.py) &hearts; [Java](https://github.com/qiyuangong/leetcode/blob/master/java/253_Meeting_Rooms_II.java) | 1. Priority queue and sort, O(nlogn) and O(n)<br>2. Go through timeline. If it's a start then meeting + 1, else meeting - 1. The ans is the max(meeting) in timeline. O(nlogn) and O(n) |
 | 259 | [3Sum Smaller](https://leetcode.com/problems/3sum-smaller/) | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/259_3Sum_Smaller.py) | 1. Reduce to two sum smaller, then binary search, O(n^2lgn) and O(1)<br>2. Reduce to two sum smaller, then two points, O(n^2) and O(1)|
 | 266 | [Palindrome Permutation](https://leetcode.com/problems/palindrome-permutation/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/266_Palindrome_Permutation.py) | Compute frequency, check number of odd occurrences <= 1 then palindrome, O(n) and O(n)|
 | 267 | [Palindrome Permutation II](https://leetcode.com/problems/palindrome-permutation-ii/) &hearts; | [Python](https://github.com/qiyuangong/leetcode/blob/master/python/267_Palindrome_Permutation_II.py) | Check palindrome then generate half with [Permutations II](https://leetcode.com/problems/permutations-ii/), O(n^2) and O(n^2) |

java/253_Meeting_Rooms_II.java

@@ -0,0 +1,77 @@
+/**
+ * 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; } }
+ */
+class Solution {
+
+ /* public int minMeetingRooms(Interval[] intervals) {
+
+    // Check for the base case. If there are no intervals, return 0
+    if (intervals.length == 0) {
+      return 0;
+    }
+    // Min heap
+    PriorityQueue<Integer> allocator =
+        new PriorityQueue<Integer>(
+            intervals.length,
+            new Comparator<Integer>() {
+              public int compare(Integer a, Integer b) {
+                return a - b;
+              }
+            });
+
+    // Sort the intervals by start time
+    Arrays.sort(
+        intervals,
+        new Comparator<Interval>() {
+          public int compare(Interval a, Interval b) {
+            return a.start - b.start;
+          }
+        });
+    // Add the first meeting
+    allocator.add(intervals[0].end);
+
+    // Iterate over remaining intervals
+    for (int i = 1; i < intervals.length; i++) {
+      // If the room due to free up the earliest is free, assign that room to this meeting.
+      if (intervals[i].start >= allocator.peek()) {
+        allocator.poll();
+      }
+      // If a new room is to be assigned, then also we add to the heap,
+      // If an old room is allocated, then also we have to add to the heap with updated end time.
+      allocator.add(intervals[i].end);
+    }
+    // The size of the heap tells us the minimum rooms required for all the meetings.
+    return allocator.size();
+  }*/
+
+  public int minMeetingRooms(Interval[] intervals) {
+    int ans = 0, curr = 0;
+    List<TimePoint> timeline = new ArrayList<>();
+    for (Interval interval: intervals) {
+      timeline.add(new TimePoint(interval.start, 1));
+      timeline.add(new TimePoint(interval.end, -1));
+    }
+    timeline.sort(new Comparator<TimePoint>() {
+          public int compare(TimePoint a, TimePoint b) {
+            if (a.time != b.time) return a.time - b.time;
+            else return a.room - b.room;
+          }
+        });
+    for (TimePoint t: timeline) {
+      curr += t.room;
+      if (curr >= ans) ans = curr;
+    }
+    return ans;
+  }  
+
+  private class TimePoint {
+    int time;
+    int room;
+
+    TimePoint(int time, int room) {
+      this.time = time;
+      this.room = room;
+    }
+  }
+}

python/253_Meeting_Rooms_II.py

@@ -0,0 +1,55 @@
+# Definition for an interval.
+# class Interval(object):
+#     def __init__(self, s=0, e=0):
+#         self.start = s
+#         self.end = e
+
+
+# class Solution(object):
+#     def minMeetingRooms(self, intervals):
+#         """
+#         :type intervals: List[Interval]
+#         :rtype: int
+#         """
+#         # If there is no meeting to schedule then no room needs to be allocated.
+#         if not intervals:
+#             return 0
+#         # The heap initialization
+#         free_rooms = []
+#         # Sort the meetings in increasing order of their start time.
+#         intervals.sort(key= lambda x: x.start)
+#         # Add the first meeting. We have to give a new room to the first meeting.
+#         heapq.heappush(free_rooms, intervals[0].end)
+#         # For all the remaining meeting rooms
+#         for i in intervals[1:]:
+#             # If the room due to free up the earliest is free, assign that room to this meeting.
+#             if free_rooms[0] <= i.start:
+#                 heapq.heappop(free_rooms)
+#             # If a new room is to be assigned, then also we add to the heap,
+#             # If an old room is allocated, then also we have to add to the heap with updated end time.
+#             heapq.heappush(free_rooms, i.end)
+#         # The size of the heap tells us the minimum rooms required for all the meetings.
+#         return len(free_rooms)
+
+
+class Solution(object):
+    def minMeetingRooms(self, intervals):
+        """
+        :type intervals: List[Interval]
+        :rtype: int
+        """
+        timeline = []
+        for interval in intervals:
+            # meeting root + 1
+            timeline.append((interval.start, 1))
+            # meeting root - 1
+            timeline.append((interval.end, -1))
+        # sort by time
+        timeline.sort()
+        ans = curr = 0
+        # go through timeline
+        for _, v in timeline:
+            curr += v
+            # max meeting room used at this point
+            ans = max(ans, curr)
+        return ans