updates

Author: wuduhren

problems/python3/gas-station.py

@@ -0,0 +1,23 @@
+"""
+First thing, you must understand that if sum(gas)>=sum(cost) there must be an answer. Guaranteed.
+If we know there is an answer, we can simply test all the index.
+If the currGas ever drops to below 0, it means that we need to switch a "start".
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution:
+    def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:
+        if sum(gas)<sum(cost): return -1
+        
+        start = 0
+        currGas = 0
+        
+        for i in range(len(gas)):
+            currGas += gas[i]-cost[i]
+            
+            if currGas<0:
+                currGas = 0
+                start = i+1
+        
+        return start

problems/python3/jump-game-ii.py

@@ -0,0 +1,22 @@
+"""
+l and r is the index range we can reach within "steps".
+So while r can not reach the end (`r<len(nums)-1`), we keep update l, r and steps.
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution:
+    def jump(self, nums: List[int]) -> int:
+        l = r = 0
+        steps = 0
+        
+        while r<len(nums)-1:
+            farest = float('-inf')
+            for i in range(l, r+1):
+                farest = max(farest, i+nums[i])
+            
+            l = r+1
+            r = farest
+            steps += 1
+            
+        return steps

problems/python3/jump-game.py

@@ -0,0 +1,10 @@
+class Solution:
+    def canJump(self, nums: List[int]) -> bool:
+        maxIndex = 0
+        
+        for i, num in enumerate(nums):
+            if maxIndex<i:
+                return False
+            maxIndex = max(maxIndex, i+num)
+            
+        return True

problems/python3/maximum-subarray.py

@@ -0,0 +1,17 @@
+"""
+Time: O(N)
+Space: O(1)
+
+Calculate the prefix sum. Whenever the prefix is negative, we ignore all the value before.
+Update the ans along the way.
+"""
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        ans = float('-inf')
+        currSum = 0
+        
+        for num in nums:
+            if currSum<0: currSum = 0
+            currSum += num
+            ans = max(ans, currSum)
+        return ans

problems/python3/median-of-two-sorted-arrays.py

@@ -1,3 +1,16 @@
+"""
+Try to find a i on array A and corespoding j on array B.
+
+Aleft = A[i]
+Aright = A[i+1]
+Bleft = B[j]
+Bright = B[j+1]
+
+Such that Aleft<=Bright and Bleft<=Aright
+
+This means that A[:i+1] and B[:j+1] holds all the elements that is less than the median.
+Aright A[i+1:] and B[j+1:] holds all the elements that is larger or equal to the median.
+"""
 class Solution:
     def findMedianSortedArrays(self, A: List[int], B: List[int]) -> float:
         if len(A)>len(B): A, B = B, A