updates

Author: wuduhren

problems/python3/insert-interval.py

@@ -0,0 +1,23 @@
+class Solution:
+    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:
+        ans = []
+        i = 0
+        
+        #add intervals before newInterval
+        while i<len(intervals) and intervals[i][1]<newInterval[0]:
+            ans.append(intervals[i])
+            i += 1
+        
+        #add newInterval and merge the overlapped
+        ans.append(newInterval)
+        while i<len(intervals) and intervals[i][0]<=ans[-1][1]:
+            ans[-1][0] = min(ans[-1][0], intervals[i][0])
+            ans[-1][1] = max(ans[-1][1], intervals[i][1])
+            i += 1
+        
+        #add intervals after newInterval
+        while i<len(intervals):
+            ans.append(intervals[i])
+            i += 1
+            
+        return ans

problems/python3/meeting-rooms-ii.py

@@ -0,0 +1,12 @@
+class Solution:
+    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
+        intervals.sort()
+        h = []
+        ans = 0
+        
+        for s, e in intervals:
+            while h and s>=h[0][0]:
+                heapq.heappop(h)
+            heapq.heappush(h, (e, s))
+            ans = max(ans, len(h))
+        return ans

problems/python3/meeting-rooms.py

@@ -0,0 +1,10 @@
+class Solution:
+    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
+        intervals.sort()
+        lastEnd = float('-inf')
+        for s, e in intervals:
+            if lastEnd>s:
+                return False
+            else:
+                lastEnd = e
+        return True

problems/python3/minimum-interval-to-include-each-query.py

@@ -0,0 +1,23 @@
+class Solution:
+    def minInterval(self, intervals: List[List[int]], queries: List[int]) -> List[int]:
+        ans = [-1]*len(queries)
+        queries = sorted([(query, i) for i, query in enumerate(queries)])
+        intervals.sort()
+        h = []
+        
+        itervalIndex = 0
+        for query, queryIndex in queries:
+            #push all intervals that include 'query' to the min heap
+            while itervalIndex<len(intervals) and intervals[itervalIndex][0]<=query:
+                left = intervals[itervalIndex][0]
+                right = intervals[itervalIndex][1]
+                size = right-left+1
+                heapq.heappush(h, (size, right))
+                itervalIndex += 1
+            
+            #pop all intervals that not includes 'query' out of the min heap
+            while h and h[0][1]<query:
+                heapq.heappop(h)
+                
+            if h: ans[queryIndex] = h[0][0]
+        return ans

problems/python3/non-overlapping-intervals.py

@@ -0,0 +1,17 @@
+"""
+Time: O(NLogN) for sorting.
+"""
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        intervals.sort()
+        
+        ans = 0
+        prevEnd = intervals[0][1]
+        
+        for s, e in intervals[1:]:
+            if s>=prevEnd:
+                prevEnd = e
+            else:
+                ans += 1
+                prevEnd = min(prevEnd, e)
+        return ans