850. Rectangle Area II

Author: Partho Biswas

README.md

@@ -690,6 +690,7 @@ BFS, DFS, Dijkstra, Floyd–Warshall, Bellman-Ford, Kruskal, Prim's, Minimum Spa
 |05| [1272. Remove Interval](https://tinyurl.com/syvucrt) | [Python](https://tinyurl.com/wu6rdaw/1272_Remove_Interval.py)| [Art 1](https://tinyurl.com/srv4knp) | Medium | **Line Swap** |
 |06| [1288. Remove Covered Intervals](https://tinyurl.com/wc72tcx) | [Python](https://tinyurl.com/wu6rdaw/1288_Remove_Covered_Intervals.py)| [Art 1](https://tinyurl.com/vpp5hnx) | Medium | **Line Swap with Greedy**. A must read solution. A gold mie, learned a lot |
 |07| [1229. Meeting Scheduler](https://tinyurl.com/t6vtlph) | [Python](https://tinyurl.com/wu6rdaw/1229_Meeting_Scheduler.py)| [Art 1](https://tinyurl.com/rau4xcb) | Medium | **Line Swap**, learned a lot |
+|08| [850. Rectangle Area II](https://tinyurl.com/utc58vb) | [Python](https://tinyurl.com/wu6rdaw/850_Rectangle_Area_II.py)| [Art 1](https://tinyurl.com/t59zg3e), [Vid 1](https://tinyurl.com/sumo5b6), [Art 2](https://tinyurl.com/s27k9o4) | Hard | **Line Swap using heap and Segmet Tree**. TODO: Solve it using Segment Tree |
 
 </p>
 </details>

leetcode.com/python/253_Meeting_Rooms_II.py

@@ -2,37 +2,48 @@
 
 
 #   Solution 01: Official solution from leetcode itself
+#   Definition for an interval.
+class Interval(object):
+    def __init__(self, s=0, e=0):
+        self.start = s
+        self.end = e
+
+
+#   Official solution from leetcode itself
 class Solution(object):
     def minMeetingRooms(self, intervals):
         """
-        :type intervals: List[List[int]]
+        :type intervals: List[Interval]
         :rtype: int
         """
-        if len(intervals) < 1:
+
+        # If there is no meeting to schedule then no room needs to be allocated.
+        if not intervals:
             return 0
+
         # The heap initialization
-        usedRooms = []
+        occupied_rooms = []
 
-        # Sort the meetings in increasing order of their start time
+        # Sort the meetings in increasing order of their start time.
         intervals.sort(key= lambda x: x[0])
 
-        # Add  the first meetinng. we have to give a new room to the first meeting
-        heapq.heappush(usedRooms, intervals[0][1])
+        # Add the first meeting. We have to give a new room to the first meeting.
+        # We are storing the meeting's END time into the heap,  So that we can know which meetiing is going to end first and we can assign new meetings aaccordingly
+        heapq.heappush(occupied_rooms, intervals[0][1])
 
         # For all the remaining meeting rooms
         for interval in intervals[1:]:
 
             # If the room due to free up the earliest is free, assign that room to this meeting.
-            if interval[0] >= usedRooms[0]:
-                heapq.heappop(usedRooms)
+            if occupied_rooms[0] <= interval[0]:
+                heapq.heappop(occupied_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(usedRooms, interval[1])
+            heapq.heappush(occupied_rooms, interval[1])
+
+        return len(occupied_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.
-        return len(usedRooms)
 
 
 

leetcode.com/python/850_Rectangle_Area_II.py

@@ -0,0 +1,45 @@
+# Source: https://tinyurl.com/t59zg3e
+# Approach 3: Line Sweep
+# Time Complexity: O(N^2 log N) , nlogn is for sorting. the intervals and n is for the length. of intervals
+# https://tinyurl.com/v9mdkla
+class Solution(object):
+    def rectangleArea(self, rectangles):
+        """
+        :type rectangles: List[List[int]]
+        :rtype: int
+        """
+        # Pre processing, populate events
+        OPEN, CLOSE = 0, 1
+        events = []
+        for x1, y1, x2, y2 in rectangles:
+            events.append((y1, OPEN, x1, x2))
+            events.append((y2, CLOSE, x1, x2))
+        events.sort()
+
+        active = []
+        prevY = events[0][0]
+        area = 0
+        for currY, itervalType, openX1, closeX2 in events:
+            # For all vertical ground covered, update answer
+            height = currY - prevY
+            width = self.mergeInterval(active)
+            area += width * height
+
+            if itervalType is OPEN:
+                active.append((openX1, closeX2))
+                active.sort()
+            else:
+                active.remove((openX1, closeX2))
+
+            prevY = currY
+
+        return area % (10 ** 9 + 7)
+
+    # This calculates the total horizontal length of our active intervals
+    def mergeInterval(self, activeIntervals):
+        width, prevX1 = 0, -1
+        for x1, x2 in activeIntervals:
+            prevX1 = max(prevX1, x1)
+            width += max(0, x2 - prevX1)
+            prevX1 = max(prevX1, x2)
+        return width