update

Author: tiationg-kho

README.md

@@ -0,0 +1,96 @@
+class Solution:
+    def minAvailableDuration(self, slots1: List[List[int]], slots2: List[List[int]], duration: int) -> List[int]:
+        slots1.sort()
+        slots2.sort()
+        i, j = 0, 0
+        res = []
+        while i < len(slots1) and j < len(slots2):
+            s1, e1 = slots1[i]
+            s2, e2 = slots2[j]
+            if e1 < s2:
+                i += 1
+            elif e2 < s1:
+                j += 1
+            else:
+                interval = [max(s1, s2), min(e1, e2)]
+                if interval[1] - interval[0] >= duration:
+                    res.append(interval[0])
+                    res.append(interval[0] + duration)
+                    break
+                elif e1 < e2:
+                    i += 1
+                else:
+                    j += 1
+        
+        return res
+    
+# time O(mlogm + nlogn)
+# space O(1), not counting built in sort cost
+# using array and line sweep and compare two intervals each round and two pointers and greedy and sort
+
+class Solution:
+    def minAvailableDuration(self, slots1: List[List[int]], slots2: List[List[int]], duration: int) -> List[int]:
+        
+        intervals = []
+        for s, e in slots1:
+            if e - s >= duration:
+                intervals.append([s, e])
+        for s, e in slots2:
+            if e - s >= duration:
+                intervals.append([s, e])
+        intervals.sort()
+
+        res = []
+        if intervals:
+            prev_s, prev_e = intervals[0]
+        for i in range(1, len(intervals)):
+            cur_s, cur_e = intervals[i]
+            if prev_e < cur_s:
+                prev_s, prev_e = cur_s, cur_e
+            else:
+                interval = [max(prev_s, cur_s), min(prev_e, cur_e)]
+                if interval[1] - interval[0] >= duration:
+                    res.append(interval[0])
+                    res.append(interval[0] + duration)
+                    break
+                if cur_e > prev_e:
+                    prev_s, prev_e = cur_s, cur_e
+        return res
+
+# time O((m+n)log(m+n))
+# space O(m+n)
+# using array and line sweep and compare two intervals each round and greedy and sort and prune
+
+from heapq import *
+class Solution:
+    def minAvailableDuration(self, slots1: List[List[int]], slots2: List[List[int]], duration: int) -> List[int]:
+        
+        events = []
+        for s, e in slots1:
+            if e - s >= duration:
+                events.append((s, 1))
+                events.append((e, - 1))
+        for s, e in slots2:
+            if e - s >= duration:
+                events.append((s, 1))
+                events.append((e, - 1))
+
+        heapify(events)
+        status = 0
+        prev_timestamp = 0
+        res = []
+        while events:
+            timestamp, weight = heappop(events)
+            if status == 2:
+                interval = [prev_timestamp, timestamp]
+                if interval[1] - interval[0] >= duration:
+                    res.append(interval[0])
+                    res.append(interval[0] + duration)
+                    break
+            prev_timestamp = timestamp
+            status += weight
+        return res
+
+# time O((m+n)log(m+n))
+# space O(m+n)
+# using array and line sweep and and greedy and heap and prune

[H]array/[H]array-line-sweep/1229-meeting-scheduler.py

@@ -0,0 +1,22 @@
+class Solution:
+    def removeInterval(self, intervals: List[List[int]], toBeRemoved: List[int]) -> List[List[int]]:
+        
+        res = []
+        prev_s, prev_e = toBeRemoved
+        for i, (cur_s, cur_e) in enumerate(intervals):
+            if cur_s >= prev_e:
+                res.extend(intervals[i:])
+                return res
+            elif cur_e <= prev_s:
+                res.append([cur_s, cur_e])
+            else:
+                if cur_s < prev_s:
+                    res.append([cur_s, prev_s])
+                if cur_e > prev_e:
+                    res.append([prev_e, cur_e])
+        
+        return res
+    
+# time O(n)
+# space O(n), due to output list
+# using array and line sweep and compare two intervals each round

[H]array/[H]array-line-sweep/1272-remove-interval.py

@@ -0,0 +1,18 @@
+class Solution:
+    def removeCoveredIntervals(self, intervals: List[List[int]]) -> int:
+        intervals.sort(key = lambda x: (x[0], - x[1]))
+
+        res = 0
+        prev_s, prev_e = intervals[0]
+        for i in range(1, len(intervals)):
+            cur_s, cur_e = intervals[i]
+            if prev_e >= cur_e:
+                res += 1
+            else:
+                prev_s, prev_e = cur_s, cur_e
+
+        return len(intervals) - res
+        
+# time O(nlogn)
+# space O(1) or consider the built in sort's cost
+# using array and line sweep and compare two intervals each round and sort and greedy

[H]array/[H]array-line-sweep/1288-remove-covered-intervals.py

@@ -0,0 +1,34 @@
+from heapq import *
+class Solution:
+    def minInterval(self, intervals: List[List[int]], queries: List[int]) -> List[int]:
+
+        intervals.sort()
+        queries = [(q, i) for i, q in enumerate(queries)]
+        queries.sort()
+        res = [- 1 for _ in range(len(queries))]
+
+        heap = []
+        idx = 0
+        for q, i in queries:
+            while idx < len(intervals):
+                s, e = intervals[idx]
+                if q < s:
+                    break
+                elif e < q:
+                    idx += 1
+                else:
+                    heappush(heap, (e - s + 1, s, e))
+                    idx += 1
+            
+            while heap:
+                length, s, e = heap[0]
+                if e < q:
+                    heappop(heap)
+                else:
+                    res[i] = length
+                    break
+        return res
+    
+# time O(nlogn + qlogq)
+# space O(n + q)
+# using array and line sweep and heap to store previous intervals’ states and greedy and sort

[H]array/[H]array-line-sweep/1851-minimum-interval-to-include-each-query.py

@@ -0,0 +1,20 @@
+class Solution:
+    def canAttendMeetings(self, intervals: List[List[int]]) -> bool:
+        if not intervals:
+            return True
+        
+        intervals.sort()
+
+        prev_s, prev_e = intervals[0]
+        for i in range(1, len(intervals)):
+            cur_s, cur_e = intervals[i]
+            if prev_e <= cur_s:
+                prev_s, prev_e = cur_s, cur_e
+                continue
+            return False
+
+        return True
+
+# time O(nlogn)
+# space O(1), or consider sort's cost
+# using array and line sweep and compare two intervals each round

[H]array/[H]array-line-sweep/252-meeting-rooms.py

@@ -0,0 +1,56 @@
+from heapq import *
+class Solution:
+    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
+        
+        intervals.sort()
+
+        heap = []
+        for s, e in intervals:
+            if heap and heap[0] <= s:
+                heappop(heap)
+            heappush(heap, e)
+        return len(heap)
+
+# time O(nlogn)
+# space O(n)
+# using array and line sweep and heap to store previous intervals’ states
+
+from heapq import *
+class Solution:
+    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
+        
+        intervals.sort()
+
+        heap = []
+        res = 0
+        for s, e in intervals:
+            while heap and heap[0] <= s:
+                heappop(heap)
+            heappush(heap, e)
+            res = max(res, len(heap))
+        return res
+
+# time O(nlogn)
+# space O(n)
+# using array and line sweep and heap to store previous intervals’ states
+
+class Solution:
+    def minMeetingRooms(self, intervals: List[List[int]]) -> int:
+        
+        events = []
+
+        for s, e in intervals:
+            events.append((s, 1))
+            events.append((e, - 1))
+        events.sort()
+
+        status = 0
+        res = 0
+        for timestamp, weight in events:
+            status += weight
+            res = max(res, status)
+        return res
+
+# time O(nlogn)
+# space O(n)
+# using array and line sweep and sort

[H]array/[H]array-line-sweep/253-meeting-rooms-ii.py

@@ -0,0 +1,21 @@
+class Solution:
+    def eraseOverlapIntervals(self, intervals: List[List[int]]) -> int:
+        
+        intervals.sort()
+
+        res = 0
+        prev_s, prev_e = intervals[0]
+        for i in range(1, len(intervals)):
+            cur_s, cur_e = intervals[i]
+            if prev_e <= cur_s:
+                prev_s, prev_e = cur_s, cur_e
+            else:
+                if cur_e < prev_e:
+                    prev_s, prev_e = cur_s, cur_e
+                res += 1
+        
+        return res
+
+# time O(nlogn)
+# space O(1), or due to built in sort's cost
+# using array and line sweep and compare two intervals each round and sort and greedy

[H]array/[H]array-line-sweep/435-non-overlapping-intervals.py

@@ -0,0 +1,49 @@
+class Solution:
+    def findMinArrowShots(self, points: List[List[int]]) -> int:
+        
+        points.sort()
+
+        res = 0
+        prev_e = points[0][1]
+        for i in range(1, len(points)):
+            cur_s, cur_e = points[i]
+            if prev_e < cur_s:
+                res += 1
+                prev_e = cur_e
+            else:
+                prev_e = min(prev_e, cur_e)
+            
+        res += 1
+
+        return res
+    
+# time O(nlogn)
+# space O(1), not counting built in sort cost
+# using array and line sweep and compare two intervals each round and sort and greedy
+'''
+1. only end ptr matters
+'''
+
+class Solution:
+    def findMinArrowShots(self, points: List[List[int]]) -> int:
+        
+        points.sort(key = lambda x: x[1])
+
+        res = 0
+        prev_e = points[0][1]
+        for i in range(1, len(points)):
+            cur_s, cur_e = points[i]
+            if prev_e < cur_s:
+                res += 1
+                prev_e = cur_e
+            
+        res += 1
+
+        return res
+
+# time O(nlogn)
+# space O(1), not counting built in sort cost
+# using array and line sweep and compare two intervals each round and sort and greedy
+'''
+1. only end ptr matters
+'''

[H]array/[H]array-line-sweep/452-minimum-number-of-arrows-to-burst-balloons.py

@@ -0,0 +1,51 @@
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        
+        intervals.sort()
+
+        res = []
+        prev_s, prev_e = intervals[0]
+        for i in range(1, len(intervals)):
+            cur_s, cur_e = intervals[i]
+            if prev_e < cur_s:
+                res.append([prev_s, prev_e])
+                prev_s, prev_e = cur_s, cur_e
+            else:
+                prev_e = max(prev_e, cur_e)
+
+        res.append([prev_s, prev_e])
+
+        return res
+        
+# time O(nlogn)
+# space O(n), due to output and sort
+# using array and line sweep and compare two intervals each round and sort
+
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        
+        events = []
+        for s, e in intervals:
+            events.append((s, 1))
+            events.append((e, - 1))
+        events.sort(key = lambda x: (x[0], - x[1]))
+
+        res = []
+        status = 0
+        prev_timestamp = 0
+
+        for timestamp, weight in events:
+            if status == 0 and weight == 1:
+                prev_timestamp = timestamp
+            if status == 1 and weight == - 1:
+                res.append([prev_timestamp, timestamp])
+            status += weight
+
+        return res
+                
+# time O(nlogn)
+# space O(n), due to output and sort
+# using array and line sweep and sort
+'''
+1. if certain timestamp have both start and end event, let start event become first
+'''