Runtime: 1741 ms (Top 100.0%) | Memory: 67.86 MB (Top 93.7%)

Author: AnasImloul

scripts/algorithms/C/Closest Room/Closest Room.py

@@ -1,31 +1,33 @@
-# Runtime: 3555 ms (Top 46.27%) | Memory: 66.7 MB (Top 10.45%)
-
-from sortedcontainers import SortedList
+# Runtime: 1741 ms (Top 100.0%) | Memory: 67.86 MB (Top 93.7%)
 
 class Solution:
     def closestRoom(self, rooms: List[List[int]], queries: List[List[int]]) -> List[int]:
-        rooms.sort(key=lambda x: x[1], reverse=True) # Sort by decreasing order of room size
-        qArr = [[i, q] for i, q in enumerate(queries)] # Zip queries with their index
-        qArr.sort(key=lambda x: x[1][1], reverse=True) # Sort by decreasing order of query minSize
+        ans = [0] * len(queries)
+        
+        # sort queries to handle largest size queries first
+        q = deque(sorted([(size, room, i) for i, (room, size) in enumerate(queries)], key=lambda a: (-a[0], a[1], a[2])))
 
-        def searchClosestRoomId(preferredId):
-            if len(roomIdsSoFar) == 0:
-                return -1
-            cands = []
-            i = roomIdsSoFar.bisect_right(preferredId)
-            if i > 0:
-                cands.append(roomIdsSoFar[i - 1])
-            if i < len(roomIdsSoFar):
-                cands.append(roomIdsSoFar[i])
-            return min(cands, key=lambda x: abs(x - preferredId))
+        # sort rooms by descending size
+        rooms = deque(sorted(rooms, key=lambda x: -x[1]))
 
-        roomIdsSoFar = SortedList()
-        n, k = len(rooms), len(queries)
-        i = 0
-        ans = [-1] * k
-        for index, (prefferedId, minSize) in qArr:
-            while i < n and rooms[i][1] >= minSize:
-                roomIdsSoFar.add(rooms[i][0]) # Add id of the room which its size >= query minSize
-                i += 1
-            ans[index] = searchClosestRoomId(prefferedId)
+        # current available room ids
+        cands = []
+        
+        
+        while q:
+            size, room, i = q.popleft()
+            # add room ids to candidates as long as top of room size meet the requirements
+            while rooms and rooms[0][1] >= size:
+                bisect.insort(cands, rooms.popleft()[0])
+                    
+            # if no room size available, return -1
+            if not cands: ans[i] = -1
+                
+            # else use bisect to find optimal room ids
+            else:
+                loc = bisect.bisect_left(cands, room)
+                if loc == 0: ans[i] = cands[loc]
+                elif loc == len(cands): ans[i] = cands[-1]
+                else: ans[i] = cands[loc - 1] if room - cands[loc - 1] <= cands[loc] - room else cands[loc]
+        
         return ans