no message

Author: Chris Wu

problems/capacity-to-ship-packages-within-d-days.py

@@ -0,0 +1,48 @@
+class Solution(object):
+    def shipWithinDays(self, weights, D):
+        l = max(weights)
+        r = sum(weights)
+        
+        while l<r:
+            c = (l+r)/2
+            
+            #calculate with weight capacity c, how many days we need, d.
+            d = 0
+            daily_weight = 0
+            for w in weights:
+                if daily_weight+w<=c:
+                    daily_weight+=w
+                else:
+                    daily_weight = w
+                    d += 1
+            if daily_weight: d += 1
+
+            if d>D:
+                #K cannot be the answer.
+                #next round we don't need to put K in l~r.
+                l = c+1
+            else:
+                #K might ot might not be the answer.
+                #next round we still need to put K in l~r.
+                r = c
+        return l
+
+"""
+This is a binary search problem.
+If you do not understand binary search yet, please study it first.
+
+[0]
+Lets define the possible range, `l` and `r`, of our answer, the least weight capacity of the ship that can diliver all packages within D days.
+The ship must at least carry the heaviest package, so `l = max(weights)`.
+The best ship scenario is that we can carry all packages at once, so `r = sum(weights)`.
+
+[1]
+For every iteration, we try a `c` (capacity) and adjust `l` and `r`.
+Note that, even if `d<=D`, we still need to see if there are any smaller `d`.
+
+[2]
+So the boundary of our answer, `l` and `r`, will collides together (`l==r`) and jump out of the loop.
+
+Time complexity: `O(NlogN)`. There will be `O(LogN)` iteration. For every iteration we need O(N) to calculate the `t`. `N` is the length of `piles`.
+Space complexity is O(N). For calculating `t`.
+"""

problems/koko-eating-bananas.py

@@ -29,3 +29,49 @@ def canEatAll(time):
             else:
                 l = m+1
         return l
+
+
+#2020/7/23
+class Solution(object):
+    def minEatingSpeed(self, piles, H):
+        if not piles: return 0
+        
+        l = 1
+        r = max(piles) #[0]
+        
+        while l<r:
+            K = (l+r)/2 #[1]
+            
+            #time Koko needs to eat all bananas
+            t = sum([-(-banana_count//K) for banana_count in piles]) #-(-a//b) means ceil(a/b)
+            
+            if t>H:
+                #K cannot be the answer.
+                #next round we don't need to put K in l~r.
+                l = K+1
+            else:
+                #K might ot might not be the answer.
+                #next round we still need to put K in l~r.
+                r = K
+
+        return l #[2]
+
+"""
+This is a binary search problem.
+If you do not understand binary search yet, please study it first.
+
+[0]
+Lets define the possible range, `l` and `r`, of our answer, the minimum integer `K` such that Koko can eat all the bananas within `H` hours.
+The best scenario is that Koko can eat the whole pile at once.
+So `K` must be between 1 ~ `max(piles)`. `l = 1`, `r = max(piles)`.
+
+[1]
+For every iteration, we try a `K` and adjust `l` and `r`.
+Note that, even if `t<=H`, we still need to see if there are any smaller `K`.
+
+[2]
+So the boundary of our answer, `l` and `r`, will collides together (`l==r`) and jump out of the loop.
+
+Time complexity: `O(NlogN)`. There will be `O(LogN)` iteration. For every iteration we need O(N) to calculate the `t`. `N` is the length of `piles`.
+Space complexity is O(N). For calculating `t`.
+"""

problems/search-a-2d-matrix.py

@@ -47,3 +47,51 @@ def getMatrix(i):
             else:
                 l = p+1
         return False
+
+
+#2020/7/23
+class Solution(object):
+    def searchMatrix(self, matrix, target):
+        if not matrix or not matrix[0]: return False
+        
+        #if you do not understand binary search yet, please study it first.
+        #use binary search to find the list that has target.
+        #if found, asign it to A.
+        l = 0
+        r = len(matrix)-1
+        A = None
+        while l<=r:
+            if matrix[l][0]<=target and target<=matrix[l][-1]:
+                A = matrix[l]
+                break
+            if matrix[r][0]<=target and target<=matrix[r][-1]:
+                A = matrix[r]
+                break
+            
+            m = (l+r)/2
+            
+            if matrix[m][0]<=target and target<=matrix[m][-1]:
+                A = matrix[m]
+                break
+            elif target<matrix[m][0]:
+                r = m-1
+            else:
+                l = m+1
+        
+        if not A: return False
+        
+        #find if target in A
+        l = 0
+        r = len(A)-1
+        while l<=r:
+            if target==A[l] or target==A[r]: return True
+            
+            m = (l+r)/2
+            
+            if target==A[m]:
+                return True
+            elif target<A[m]:
+                r = m-1
+            else:
+                l = m+1
+        return False