Update 44 2022 0531 heap 7th.md

Author: the-yuyut

紀錄/44 2022 0531 heap 7th.md

@@ -29,12 +29,150 @@
 
 ---
 
-業配我的 Github 跟解法: [louis222220 - No. 973 in TypeScript](https://github.com/louis222220/leetcode-practice/commit/fcf507e23cb954cc7e78444239fd98305af149b5)
 
-- 嘗試優化：提前把所有點的距離算出來，再做排序，減少排序期間做了多餘的距離計算
-![](https://i.imgur.com/5FKMaxz.png)
+```python
+from typing import List
+import heapq
+class Solution:
+    def furthestBuilding(self, heights: List[int], bricks: int, ladders: int) -> int:
+        # a. use ladder optimally
+        # keep tracking the usage of bricks
+        # and if the sum of usage is more than bricks we have, we'll need ladder anyway)
+        # use the ladder at the 'biggest gap', and minus from the sum of usage
+        
+        # b. use bricks optimally
+        # the other way around is to use bricks optimally:
+        # keep add gaps into the heap, and we only pop out the 'smallest gap' for brick usage
+        
+        # time O(N*logN), where N is the length of heights
+        # space O(N)
+        
+        prev = float('inf')             # 最大的
+        hp = []                         # heap of brick usage
+        brick_needed = 0                # sum of gaps
 
-Louis 提議下次 1642 if end early we can do 295 (hard) Problem brief 
+        for i in range(len(heights)):
 
+            # use ladder optimally
+            if heights[i] > prev:
+                brick_needed += heights[i]-prev
+                heapq.heappush(hp, prev-heights[i])
+                if brick_needed > bricks:
+                    if ladders > 0:
+                        brick_needed += heapq.heappop(hp)       # max heap (update brick_needed so we don't need so much)
+                        # a.k.a. brick_needed -= -heapq.heappop(hp)
+                        ladders -= 1
+                    else:
+                        return i-1
 
----
+            # use bricks optimally
+            # if heights[i] > prev:
+            #     heapq.heappush(hp, heights[i]-prev)          
+            # if len(hp) > ladders:
+            #     brick_needed += heapq.heappop(hp)
+            # if brick_needed > bricks:
+            #     return i-1
+
+            prev = heights[i]
+            
+
+        return len(heights)-1
+```
+
+
+
+```python
+# 871
+from typing import List
+import collections
+class Solution:
+    def minRefuelStops(self, target: int, startFuel: int, stations: List[List[int]]) -> int:
+        # use DP
+        if target > startFuel+sum([f for _, f in stations]): return -1
+        if not stations: return 0 if startFuel >= target else -1
+
+        # DP / dict (times of refuel)
+        # key = refill times, value: remaining Fuel
+        trips = {0:startFuel}
+        pos, i = 0, 0
+        minRefill = float('inf')
+
+        while pos < target and i < len(stations):
+            stationPosition, stationFuel = stations[i]
+            tmp = collections.defaultdict()
+            # print('trips:', trips, 'min refills:', minRefill, 'pos:', pos, 'dis', stationPosition-pos)
+
+            for refills, remainingFuel in trips.items():
+                # print('refill, fuel, pos', refills, remainingFuel, pos)
+                if pos + remainingFuel >= target:
+                    minRefill = min(minRefill, refills)
+                elif refills > minRefill or pos + remainingFuel < stationPosition:
+                    continue
+                else:
+                    dist = stationPosition-pos
+                    if refills in tmp:
+                        tmp[refills] = max(tmp[refills], remainingFuel-dist)
+                    else:
+                        tmp[refills] = remainingFuel-dist
+                    if refills+1 in tmp:
+                        tmp[refills+1] = max(tmp[refills+1], remainingFuel-dist+stationFuel)
+                    else:
+                        tmp[refills+1] = remainingFuel-dist+stationFuel
+
+            pos, trips = stationPosition, tmp
+            i += 1
+            # print('trips now:', trips, 'at pos: ', pos)
+        
+        # print('trips:', trips, 'min refills:', minRefill, 'pos:', pos, 'i', i)
+        if pos < target and i == len(stations):
+            for refills, remainingFuel in trips.items():
+                if pos + remainingFuel >= target:
+                    minRefill = min(minRefill, refills)
+            return -1 if minRefill == float('inf') else minRefill
+
+        return min([k for k, _ in trips])
+```
+
+Y.J. Lee下午8:15
+大概兩種解法
+optimally use the 1. ladder or 2. brick
+會牽涉到 using max-heap or min-heap
+Y.J. Lee下午8:20
+那個是backtracking
+Y.J. Lee下午8:22
+嗯 我講的backtracking 單純指 undo 前一動 
+Y.J. Lee下午8:24
+你得到它了
+Louis Su下午8:28
+o(〃’▽’〃)o
+Y.J. Lee下午8:30
+阿六的質因數分解吧?
+Y.J. Lee下午8:32
+我覺得不太像
+但是這個多路並歸我沒聽過QQ
+Y.J. Lee下午8:34
+都沒人寫喔 我把我的寫法先丟hackmd好了 大家可以討論
+XD 加油站那題 我好像也有 找找
+你下午8:36
+871
+Y.J. Lee下午8:37
+Naive 不用看
+Y.J. Lee下午8:38
+萬惡 python maxheap 是負的XD
+底下就是 minheap
+Y.J. Lee下午8:40
+871 我是用DP喔
+Y.J. Lee下午8:42
+#1642這個做法應該就遍歷 array, 但是過程中 maintain 一個heap (either min or max)
+Y.J. Lee下午8:44
+sudoku 這個滿經典的 backtracking
+畫到某一格 沒步了 前面某一步一定有錯 先回溯上一步再繼續
+Y.J. Lee下午8:47
+#1642 的問題在於他沒步了不一定不是最佳解 所以變成要遍歷整個樹 會很恐怖
+沒看 +1 XD
+Y.J. Lee下午8:50
+其實dfs就很類似啦  很多情境你會直接想到dfs而不是backtracking
+Y.J. Lee下午8:52
+dfs 的 recursive call 如果有把前面做的事情undo 就會八成像 backtracking
+Y.J. Lee下午8:53
+所以我聽到 backtracking 會直覺有 undo 某些東西