Merge pull request #13 from tiationg-kho/update

update

Author: tiationg-kho

README.md

@@ -174,14 +174,14 @@ Pattern500 is inspired by Blind 75 and Grind 75's classic problem selection. Pat
 | 160 | O | [295. Find Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream/) | [E]heap | two heap problem | [Python]([E]heap/[E]heap/295-find-median-from-data-stream.py) |
 | 161 | | [502. IPO](https://leetcode.com/problems/ipo/) | [E]heap | two heap problem | [Python]([E]heap/[E]heap/502-ipo.py) |
 | 162 | | [480. Sliding Window Median](https://leetcode.com/problems/sliding-window-median/) | [E]heap | two heap problem | [Python]([E]heap/[E]heap/480-sliding-window-median.py) |
-| 163 | | [1383. Maximum Performance of a Team](https://leetcode.com/problems/maximum-performance-of-a-team/) | [E]heap | focus on stored elements  | [Python]([E]heap/[E]heap/1383-maximum-performance-of-a-team.py) |
-| 164 | O | [XX]()  | [X]XX  | XX   | [Python]()  |
-| 165 | O | [XX]()  | [X]XX  | XX   | [Python]()  |
-| 166 | | [1705. Maximum Number of Eaten Apples](https://leetcode.com/problems/maximum-number-of-eaten-apples/) | [E]heap | focus on popping out   | [Python]([E]heap/[E]heap/1705-maximum-number-of-eaten-apples.py) |
-| 167 | O | [XX]()   | [X]XX  | XX   | [Python]()  |
-| 168 | O | [XX]()   | [X]XX  | XX   | [Python]()  |
-| 169 | O | [XX]()   | [X]XX  | XX   | [Python]()  |
-| 170 | O | [XX]()   | [X]XX  | XX   | [Python]()  |
+| 163 | | [1383. Maximum Performance of a Team](https://leetcode.com/problems/maximum-performance-of-a-team/) | [E]heap | storing and popping out elements | [Python]([E]heap/[E]heap/1383-maximum-performance-of-a-team.py) |
+| 164 |  | [630. Course Schedule III](https://leetcode.com/problems/course-schedule-iii/) | [E]heap | storing and popping out elements | [Python]([E]heap/[E]heap/630-course-schedule-iii.py) |
+| 165 |  | [1094. Car Pooling](https://leetcode.com/problems/car-pooling/) | [E]heap | storing and popping out elements | [Python]([E]heap/[E]heap/1094-car-pooling.py) |
+| 166 | | [1705. Maximum Number of Eaten Apples](https://leetcode.com/problems/maximum-number-of-eaten-apples/) | [E]heap | storing and popping out elements | [Python]([E]heap/[E]heap/1705-maximum-number-of-eaten-apples.py) |
+| 167 |  | [1792. Maximum Average Pass Ratio](https://leetcode.com/problems/maximum-average-pass-ratio/) | [E]heap | storing and popping out elements | [Python]([E]heap/[E]heap/1792-maximum-average-pass-ratio.py) |
+| 168 |  | [378. Kth Smallest Element in a Sorted Matrix](https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/) | [E]heap | use bfs and heap | [Python]([E]heap/[E]heap/378-kth-smallest-element-in-a-sorted-matrix.py) |
+| 169 |  | [373. Find K Pairs with Smallest Sums](https://leetcode.com/problems/find-k-pairs-with-smallest-sums/) | [E]heap | use bfs and heap | [Python]([E]heap/[E]heap/373-find-k-pairs-with-smallest-sums.py) |
+| 170 |  | [407. Trapping Rain Water II](https://leetcode.com/problems/trapping-rain-water-ii/) | [E]heap | use bfs and heap | [Python]([E]heap/[E]heap/407-trapping-rain-water-ii.py) |
 | 171 | | [string]([F]string/string.md) | [F]string | | |
 | 172 | O | [XX]() | [X]XX | XX | [Python]() |
 | 173 | O | [XX]() | [X]XX | XX | [Python]() |

[E]heap/[E]heap/1094-car-pooling.py

@@ -0,0 +1,25 @@
+from heapq import *
+class Solution:
+ def carPooling(self, trips: List[List[int]], capacity: int) -> bool:
+ trips.sort(key = lambda x: x[1])
+ 
+ seats = capacity
+ heap = []
+ for p, s, e in trips:
+ while heap and heap[0][0] <= s:
+ prev_e, prev_p = heappop(heap)
+ seats += prev_p
+ if seats < p:
+ return False
+ heappush(heap, (e, p))
+ seats -= p
+ return True
+ 
+# time O(nlogn), due to sort, and traverse and perform heap operations
+# space O(n), due to heap
+# using heap and storing and popping out elements and sort
+'''
+1. sort by start time
+2. store (end, passengers) in heap
+3. when new passengers come, let old passengers leave (with smallest end time)
+'''

[E]heap/[E]heap/1383-maximum-performance-of-a-team.py

@@ -1,23 +1,25 @@
 from heapq import *
 class Solution:
  def maxPerformance(self, n: int, speed: List[int], efficiency: List[int], k: int) -> int:
- eng = [(e, s) for e, s in zip(efficiency, speed)]
- eng.sort(key = lambda x: - x[0])
+ 
+ engineers = [(s, e) for s, e in zip(speed, efficiency)]
+ engineers.sort(key = lambda x: - x[1])
 
  res = 0
+ total = 0
  heap = []
- total_speed = 0
- for e, s in eng:
- total_speed += s
+ for s, e in engineers:
+ total += s
  heappush(heap, s)
  if len(heap) > k:
- total_speed -= heappop(heap)
- res = max(res, e * total_speed)
- return res % (10**9 + 7)
+ total -= heappop(heap)
+ res = max(res, total * e)
+
+ return res % (10**9+7)
 
 # time O(nlogn)
 # space O(n + k)
-# using heap and focus on stored elements and sort and greedy
+# using heap and storing and popping out elements and sort and greedy
 '''
 two factors in problem, need to handle ony by one
 1. we traverse every possible team effi (from high to low), and keep recording the best perf

[E]heap/[E]heap/1705-maximum-number-of-eaten-apples.py

@@ -1,29 +1,30 @@
 from heapq import *
 class Solution:
  def eatenApples(self, apples: List[int], days: List[int]) -> int:
- res = 0
  heap = []
+ res = 0
  for i in range(len(apples)):
- count = apples[i]
- expire = i + days[i]
- if count:
- heappush(heap, [expire, count])
- while heap and (heap[0][0] <= i or heap[0][1] == 0):
+ while heap and heap[0][0] <= i:
  heappop(heap)
+ if apples[i] != 0:
+ heappush(heap, [i + days[i], apples[i]])
  if heap and heap[0][1] > 0:
  res += 1
  heap[0][1] -= 1
+ if heap[0][1] == 0:
+ heappop(heap)
 
- cur_day = len(apples)
+ cur = len(apples)
  while heap:
- expire, count = heappop(heap)
- if expire <= cur_day:
- continue
- eat = min(count, expire - cur_day)
- res += eat
- cur_day += eat
+ while heap and heap[0][0] <= cur:
+ heappop(heap)
+ if heap:
+ end, count = heappop(heap)
+ res += min(end - cur, count)
+ cur += min(end - cur, count)
+
  return res
 
 # time O(nlogn)
 # space O(n)
-# using heap and focus on popping out
+# using heap and storing and popping out elements

[E]heap/[E]heap/1792-maximum-average-pass-ratio.py

@@ -0,0 +1,19 @@
+from heapq import *
+class Solution:
+ def maxAverageRatio(self, classes: List[List[int]], extraStudents: int) -> float:
+ heap = [(-((p+1)/(t+1) - p/t), p, t) for p, t in classes]
+ heapify(heap)
+
+ while extraStudents:
+ _, p, t = heappop(heap)
+ heappush(heap, (-((p+2)/(t+2) - (p+1)/(t+1)), p + 1, t + 1))
+ extraStudents -= 1
+ 
+ ratio = 0
+ for _, p, t in heap:
+ ratio += p/t
+ return ratio / len(classes)
+
+# time O(n + mlogn)
+# space O(n)
+# using heap and storing and popping out elements

[E]heap/[E]heap/373-find-k-pairs-with-smallest-sums.py

@@ -0,0 +1,22 @@
+from heapq import *
+class Solution:
+ def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
+ heap = []
+ visited = set()
+ heappush(heap, (nums1[0] + nums2[0], 0, 0))
+ visited.add((0, 0))
+ res = []
+ while len(res) < k:
+ val, i, j = heappop(heap)
+ res.append([nums1[i], nums2[j]])
+ if i + 1 < len(nums1) and (i + 1, j) not in visited:
+ heappush(heap, (nums1[i + 1] + nums2[j], i + 1, j))
+ visited.add((i + 1, j))
+ if j + 1 < len(nums2) and (i, j + 1) not in visited:
+ heappush(heap, (nums1[i] + nums2[j + 1], i, j + 1))
+ visited.add((i, j + 1))
+ return res
+
+# time O(klogk)
+# space O(k)
+# using heap and bfs

[E]heap/[E]heap/378-kth-smallest-element-in-a-sorted-matrix.py

@@ -0,0 +1,22 @@
+from heapq import *
+class Solution:
+ def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
+ rows, cols = len(matrix), len(matrix[0])
+ heap = []
+ visited = set()
+ heappush(heap, (matrix[0][0], 0, 0))
+ visited.add((0, 0))
+ while k:
+ val, r, c = heappop(heap)
+ k -= 1
+ if r + 1 < rows and (r + 1, c) not in visited:
+ heappush(heap, (matrix[r+1][c], r + 1, c))
+ visited.add((r + 1, c))
+ if c + 1 < cols and (r, c + 1) not in visited:
+ heappush(heap, (matrix[r][c+1], r, c + 1))
+ visited.add((r, c + 1))
+ return val
+
+# time O(klogk)
+# space O(k)
+# using heap and bfs

[E]heap/[E]heap/407-trapping-rain-water-ii.py

@@ -0,0 +1,32 @@
+from heapq import *
+class Solution:
+ def trapRainWater(self, heightMap: List[List[int]]) -> int:
+ h = heightMap
+ rows, cols = len(h), len(h[0])
+ heap = []
+ visited = set()
+ for r in range(rows):
+ for c in range(cols):
+ if (r == 0 or r == rows - 1) and (r, c) not in visited:
+ heappush(heap, (h[r][c], r, c))
+ visited.add((r, c))
+ if (c == 0 or c == cols - 1) and (r, c) not in visited:
+ heappush(heap, (h[r][c], r, c))
+ visited.add((r, c))
+ 
+ res = 0
+ while heap:
+ height, r, c = heappop(heap)
+ for next_r, next_c in [(r+1, c), (r-1, c), (r, c+1), (r, c-1)]:
+ if next_r not in range(rows) or next_c not in range(cols):
+ continue
+ if (next_r, next_c) in visited:
+ continue
+ res += max(height - h[next_r][next_c], 0)
+ heappush(heap, (max(height, h[next_r][next_c]), next_r, next_c))
+ visited.add((next_r, next_c))
+ return res
+ 
+# time O(RClog(RC)), heap size is RC
+# space O(RC), due to hashset
+# using heap and bfs

[E]heap/[E]heap/630-course-schedule-iii.py

@@ -0,0 +1,29 @@
+from heapq import *
+class Solution:
+ def scheduleCourse(self, courses: List[List[int]]) -> int:
+ courses.sort(key = lambda x: x[1])
+
+ heap = []
+ cur_day = 0
+ for duration, lastday in courses:
+ if cur_day + duration <= lastday:
+ heappush(heap, - duration)
+ cur_day += duration
+ elif heap and - heap[0] > duration:
+ cur_day -= - (heappop(heap))
+ heappush(heap, - duration)
+ cur_day += duration
+
+ return len(heap)
+ 
+# time O(nlogn)
+# space O(n)
+# using heap and storing and popping out elements and sort and greedy
+'''
+1. greedy strategy
+2. we consider the course with earilier deadline first
+3. if we can take, we push in heap
+4. if we can not take, we should check any prev course can be replaced or not
+5. if so, we pop out that course with longest time, then take cur course (cur course is better choice)
+6. if not, we discard cur course
+'''

[E]heap/heap.md

@@ -91,20 +91,13 @@
  - use hashmap to record the freq of removed elements (not really removed yet)
  - maintain heap size variable to keep track of the real heap size (exclude the removed elements which recorded in hashmap)
 
-**focus on stored elements**
+**storing and popping out elements**
 
-- use heap to keep elements (min or max group)
-- keep store and pop out the invalid elements
-
-**focus on popping out**
-
-- use heap to get the cur min or max element
-- contains greedy algorithm’s idea
- - we use popping out to get the most reasonable element to utilize
+- use heap to store elements (min or max group)
+- keep popping out the invalid or useful element (comparing to cur condition)
+ - contains greedy algorithm’s idea
 
 **use bfs and heap**
 
-- this is one variation of focusing on popping out
-- use bfs to find potential valid elements
-- use hashset to record visited elements
-- use heap to get the cur min or max element
+- use bfs to find potential valid elements (use heap to replace the queue)
+- use hashset to record visited elements