update

Author: aaron.liu

Array/Meta_two_sum_max.py

@@ -1,5 +1,4 @@
-from typing import List 
-import sys
+from typing import List
 '''
 给定一个nums数组 返回数组中两个元素的最大和. 要求这两个元素不能相邻.
 

Linkedin/tallest tower.py

@@ -39,6 +39,9 @@ def max_tower_height(blocks: List[List[int]]) -> int:
 
             # 尝试使用当前砖块
             for k in range(1, count + 1):
+                # 当前重量是j 用了k块重weight的砖 所以之前的状态重量是:(j-k*weight)
+                # 之前的状态必须合法 所以j-k*weight >= 0
+                # 当前的重量必须要在当前砖的承受力之内:j<=max_support 
                 if j >= k * weight and j <= max_support:
                     dp[i][j] = max(dp[i][j], dp[i - 1][j - k * weight] + k)
 
@@ -58,8 +61,8 @@ def max_tower_height(blocks: List[List[int]]) -> int:
 # followup: 如果每块砖的高度不一样
 # 还是按照承重能力从小到大排序
 def max_tower_height_w(blocks):
-    # 按承重能力从小到大排序
-    blocks.sort(key=lambda x: x[2])
+    # 按(承重能力递增,高度递减)排序:先用 承重差且高度高的blocks
+    blocks.sort(key=lambda x: (x[2], -x[3]))
 
     n = len(blocks)
     max_weight = max(block[2] for block in blocks)

Meta/merge k interval lists.py

@@ -0,0 +1,74 @@
+'''
+https://www.1point3acres.com/bbs/forum.php?mod=viewthread&tid=1073573&page=1#pid19674457
+求 intersection of K lists of intervals
+我们定义了一个辅助函数 merge_two_interval_lists 用于合并两个区间列表并找出它们的交集。
+在主函数 find_intersection 中，我们使用分治的思想：
+如果只有一个列表，直接返回。
+否则，将列表分成两半，分别递归处理。
+最后，合并两个子问题的结果。
+
+时间复杂度分析：
+假设有 k 个列表，总共有 n 个区间。
+合并两个列表的时间复杂度是 O(n)，因为我们只需要遍历一次两个列表。
+我们需要进行 log k 次合并操作（因为每次都将问题规模减半）。
+因此，总的时间复杂度是 O(n log k)。
+
+空间复杂度分析：
+递归调用栈的深度是 O(log k)。
+在每一层递归中，我们都需要 O(n) 的空间来存储中间结果。
+
+另一种解法: for each interval list[i] 与第i-1个interval list merge
+时间复杂度O(k*n) 
+'''
+from typing import List
+
+def merge_two_interval_lists(list1:List[int], list2:List[int]):
+    i, j = 0, 0
+    result = []
+    while i < len(list1) and j < len(list2):
+        # 找到两个区间的交集
+        start = max(list1[i][0], list2[j][0])
+        end = min(list1[i][1], list2[j][1])
+        # 如果有交集，添加到结果中
+        if start <= end:
+            result.append([start, end])
+        # 移动指针
+        if list1[i][1] < list2[j][1]:
+            i += 1
+        else:
+            j += 1
+    return result
+
+def find_intersection(intervals:List[List[List[int]]]) -> List[List[int]]:
+    if not intervals:
+        return []
+    if len(intervals) == 1:
+        return intervals[0]
+    
+    # 使用分治法
+    mid = len(intervals) // 2
+    left = find_intersection(intervals[:mid])
+    right = find_intersection(intervals[mid:])
+    
+    # 合并两个结果
+    return merge_two_interval_lists(left, right)
+
+# 测试用例
+intervals1 = [
+    [[1,5], [10,14], [16,18]],
+    [[2,6], [8,10], [11,20]],
+    [[3,7], [9,12], [15,19]]
+]
+
+intervals2 = [
+    [[0,2],[5,10],[13,23],[24,25]], 
+    [[1,5],[8,12],[15,24],[25,26]]
+]
+
+intervals3 = [
+    [[1,3],[5,9]],
+    []
+]
+print(find_intersection(intervals1)) # [[3, 5], [10, 10], [11, 12], [16, 18]]
+print(find_intersection(intervals2)) # [[1, 2], [5, 5], [8, 10], [15, 23], [24, 24], [25, 25]]
+print(find_intersection(intervals3)) # []

Meta/test.py

@@ -28,7 +28,7 @@
 
 思路: 
 1.用一个二维哈希表(或者二维数组)index_to_next来表示当前source的index右边(包括index本身)每一个字母第一次出现的位置的下一个位置。
-比如abbc 那么index[0]['a']=1 index[0]['b'] = 2, index[1]['b']= 2, index[2]['b']= 3..从右向左遍历一遍source即可完成更新index_to_next
+比如abbc 那么index[0]['a']= 1 index[0]['b'] = 2, index[1]['b']= 2, index[2]['b']= 3..从右向左遍历一遍source即可完成更新index_to_next
 2.然后遍历target, source和target的位置分别记为i和j 我们执行以下操作:
 1.index_to_next[0]当中是否存在target[j] 即整个source中是否存在j 不存在则返回-1
 2.index_to_next[i]当中是否存在target[j] 如果不存在 说明source在位置i右侧不存在target[j] i应当归零从头开始找

Pins/LC1055 Shortest Way to Form String.py

@@ -1,6 +1,5 @@
 '''
 https://leetcode.com/problems/read-n-characters-given-read4/description/
-
 '''
 """
 The read4 API is already defined for you.

Pins/LC157 Read N Characters Given Read4.py

@@ -40,7 +40,6 @@ def minTransfers(self, transactions: List[List[int]]) -> int:
         if not transactions:
             return 0
 
-
         # trans[i][0]给trans[i][1] 转了trans[i][2]块钱
         # 如果最终想实现平衡(每人里外里收支为零): trans[i][0]需要被给trans[i][2]块钱, trans[i][1]需要给出trans[i][2]块钱 
         book = defaultdict(int)

Pins/LC465 Optimal Account Balancing.py

@@ -29,11 +29,9 @@
 堆中的每个元素是一个 [time, seats] 对，表示某个时间点 time 和该时间点发生的座位变化 seats
 正数表示增加座位，负数表示减少座位。
 返回处理后的事件堆，包含所有预订的开始和结束时间点。
-2. 遍历时间堆，检查每个时间段是否可以容纳 n 人。如果可以，记录这个时间段。
+2. 遍历时间堆 检查每个时间段是否可以容纳n人。如果可以 记录这个时间段。
 在遍历的过程中 通过更新当前容量cur_cap来实时跟踪可用座位情况。
-遍历结束后，如果最后一个事件后的时间段依然可以容纳 n 人，则将其加入结果列表。
-
-
+遍历结束后 如果最后一个事件后的时间段依然可以容纳n人 则将其加入结果列表。
 
 时间复杂度: O(m*logm) 其中m是预订信息的数量
 空间复杂度: O(m)
@@ -65,14 +63,13 @@ def all_available_time_slots_seating_N_seating(self, n):
         if n > self.cap:
             return []
 
-        size = len(self.time_slots_heap)
         available_intervals = []
 
         prev = self.opening
         cur_cap = self.cap
-        for i in range(size):
-            time, seats = self.time_slots_heap[i]
-
+        heap_copy = self.time_slots_heap.copy()
+        while heap_copy:
+            time, seats = heapq.heappop(heap_copy)
             # 如果当前时间 time 大于 prev（上一个时间点），且当前可用座位数 cur_cap 大于或等于 n，
             # 那么 [prev, time] 之间的时间段可以容纳 n 人，将其加入 result 列表。
             if time > prev and cur_cap >= n:
@@ -81,28 +78,27 @@ def all_available_time_slots_seating_N_seating(self, n):
             cur_cap += seats
             prev = time
 
-        # 如果堆中最后一个事件的时间点（heap[size - 1][0]）早于餐厅关闭时间 self.close，
+        # 如果堆中最后一个事件的时间点prev 早于餐厅关闭时间 self.close，
         # 说明在这个事件之后到餐厅关闭之间仍有可用时间段
-        if self.time_slots_heap[size - 1][0] < self.close:
-            available_intervals.append([self.time_slots_heap[size - 1][0], self.close])
+        if prev < self.close:
+            available_intervals.append([prev, self.close])
 
         # merge intervals in available_intervals
         # 可用的time intervals 很可能有重叠: 
         # 比如可能出现[[18, 19],[19, 22]] 两个区间是相邻的 可以合并为 [[18, 22]]
         ret = []
-
-        start = available_intervals[0][0]
-        end = available_intervals[0][1]
-        size = len(available_intervals)
-        for i in range(size):
-            if end >= available_intervals[i][0]:
-                # merge these
-                end = max(end, available_intervals[i][1])
-            else:
-                ret.append([start, end])
-                start = available_intervals[i][0]
-                end = available_intervals[i][1]
-        ret.append([start, end])
+        if available_intervals:
+            start = available_intervals[0][0]
+            end = available_intervals[0][1]
+            
+            for interval in available_intervals[1:]:
+                if end >= interval[0]:
+                    end = max(end, interval[1])
+                else:
+                    ret.append([start, end])
+                    start = interval[0]
+                    end = interval[1]
+            ret.append([start, end])
         return ret
 
 # unit test
@@ -117,9 +113,7 @@ def all_available_time_slots_seating_N_seating(self, n):
         {'start': 16, 'end': 20, 'ppl': 2}
     ]
 }
-
 rs = ReservationScheduler(restaurant)
-
 print(rs.all_available_time_slots_seating_N_seating(5))
 
 '''
@@ -189,7 +183,7 @@ def time_to_minutes(self, time_str: str) -> int:
         hour, minute = map(int, time_parts[0].split(':'))
         if 'PM' in time_parts[1] and hour != 12:
             hour += 12
-        if 'AM' in time_parts[1] and hour == 12:
+        elif 'AM' in time_parts[1] and hour == 12:
             hour = 0
         return hour * 60 + minute
 
@@ -217,7 +211,7 @@ def get_time_slots_for_heap(self, reservations: list) -> list:
 
     def available_capacity_intervals(self) -> dict[str, int]:
         result = {}
-        heap = list(self.time_slots_heap)
+        heap = self.time_slots_heap.copy() # 创建堆的副本，避免修改原始数据
 
         prev = self.opening
         cur_cap = self.capacity
@@ -227,15 +221,48 @@ def available_capacity_intervals(self) -> dict[str, int]:
 
             # 注意下面这里一定要写成">" 不能">=". 有可能出现同一个时间点 有两个事件的情况
             if time > prev:
-                # 如果只要求输出容量大于或等于K的时间段 这里加逻辑:if cur_cap >= K:
                 result[f"{self.minutes_to_time(prev)}-{self.minutes_to_time(time)}"] = cur_cap
             cur_cap += change
             prev = time
 
         # 处理营业时间结束前的最后一个时间段
-        if prev < self.closing: # and cur_cap >= K: (如果只要求输出容量大于或等于K的时间段)
+        if prev < self.closing:
             result[f"{self.minutes_to_time(prev)}-{self.minutes_to_time(self.closing)}"] = cur_cap
+        return result
+    
+    # 题目如果要求只输出容量大于或等于k的时间段
+    def available_capacity_intervals_for_K(self, k) -> dict[str, int]:
+        result = {}
+        heap = self.time_slots_heap.copy() # 创建堆的副本，避免修改原始数据
 
+        prev = self.opening
+        cur_cap = self.capacity
+        
+        # 用来跟踪上一个有效时间段的结束时间。
+        # 有助于我们合并连续的有效时间段。
+        last_valid_time = self.opening
+
+        while heap:
+            time, change = heapq.heappop(heap)
+            if time > prev:
+                if cur_cap >= k:
+                    if prev > last_valid_time:
+                        result[f"{self.minutes_to_time(prev)}-{self.minutes_to_time(time)}"] = cur_cap
+                    else:
+                        result[f"{self.minutes_to_time(last_valid_time)}-{self.minutes_to_time(time)}"] = cur_cap
+                    last_valid_time = time
+                elif prev < last_valid_time:
+                    result[f"{self.minutes_to_time(last_valid_time)}-{self.minutes_to_time(prev)}"] = result.get(f"{self.minutes_to_time(last_valid_time)}-{self.minutes_to_time(prev)}", cur_cap)
+                    last_valid_time = prev
+            cur_cap += change
+            prev = time
+
+        # 处理营业时间结束前的最后一个时间段
+        if prev < self.closing and cur_cap >= k:
+            if prev > last_valid_time:
+                result[f"{self.minutes_to_time(prev)}-{self.minutes_to_time(self.closing)}"] = cur_cap
+            else:
+                result[f"{self.minutes_to_time(last_valid_time)}-{self.minutes_to_time(self.closing)}"] = cur_cap
         return result
 
 # unit test

Pins/available time windows for guests.py

@@ -71,7 +71,6 @@ def divideImages(pairs: List[List[int]]) -> List[List[str]]:
 
     return [group1, group2]
 
-
 # unit test case 1
 pairs = [["I_1", "I_4"], ["I_4", "I_8"], ["I_8", "I_2"]]
 print(divideImages(pairs))  # [['I_1', 'I_8'], ['I_4', 'I_2']]

Pins/bi-partite image sets.py

@@ -6,7 +6,7 @@
 
 e.g
 es = [1, 2, 3, 4, 5]
-rs = [1,2, 3, 4, 5]
+rs = [1, 2, 3, 4, 5]
 K = 1
 Output: 4 since all candidates except the 0th one have at least one other candidate 
 where its engagement and relevance score is greater than another candidate
@@ -23,6 +23,11 @@
 3.统计剩余候选人
 最后统计rs优先队列中剩下的候选人数量 这个数量就是符合条件的候选人数量。
 
+注意: We need to keep track of the elements removed from the rs priority queue by storing them in a set,
+and shouldn't start the delete process if the element is already removed. 
+Otherwise we'll end up deleting all the elements from rs priority queue,
+because we'll never find the target element.
+
 时间复杂度为 O(n log n)
 空间复杂度为 O(n)
 '''
@@ -46,13 +51,16 @@ def find_greater_than_k_others(es:List[int], rs:List[int], k:int) -> int:
     # 删除前k个得分最低的候选人
     while k:
         es_score, index = heapq.heappop(es_pq)
+        # remove that element from the rs priority queue, 
+        # along with all the other elements lower than that. 
         if index not in removed:
             while rs_pq and rs_pq[0][1] != index:
                 _, popped_index = heapq.heappop(rs_pq)
                 removed.add(popped_index)    # 注意这里需要把index加到removed set中
             # 删除对应的rs中的元素
-            heapq.heappop(rs_pq)
-            removed.add(index)
+            if rs_pq:
+                heapq.heappop(rs_pq)
+                removed.add(index)
         k -= 1        
     # 剩余候选人数量即为答案
     return len(rs_pq)