updates

Author: wuduhren

problems/python3/best-time-to-buy-and-sell-stock-with-cooldown.py

@@ -0,0 +1,16 @@
+#dp[i][0] := max profit when last action is buy
+#dp[i][1] := max profit when last action is sell
+class Solution:
+    def maxProfit(self, prices: List[int]) -> int:
+        if not prices or len(prices)<=1: return 0
+        
+        N = len(prices)
+        dp = [[0, 0] for _ in range(N)]
+        dp[0] = [-prices[0], 0]
+        dp[1][0] = max(-prices[1], -prices[0])
+        dp[1][1] = max(prices[1]+dp[0][0], dp[0][1])
+        
+        for i in range(2, N):
+            dp[i][0] = max(dp[i-2][1]-prices[i], dp[i-1][0])
+            dp[i][1] = max(prices[i]+dp[i-1][0], dp[i-1][1])
+        return max(dp[-1][0], dp[-1][1], 0)

problems/python3/burst-balloons.py

@@ -0,0 +1,28 @@
+"""
+dfs(l, r) return the max coins that we can get at range l to r.
+
+```
+for i in range(l, r+1):
+    dp[(l, r)] = max(dp[(l, r)], nums[l-1]*nums[i]*nums[r+1] + dfs(l, i-1) + dfs(i+1, r))
+```
+Assuming i is the last one we extract, the max coins we can get.
+
+Start from the last becasue, we are not able to track the neighbor if we start from the first we extract.
+
+Time: O(N^3)
+Space: O(N^2)
+"""
+class Solution:
+    def maxCoins(self, nums: List[int]) -> int:
+        def dfs(l, r)->int:
+            if l>r: return 0
+            if (l, r) in dp: return dp[(l, r)]
+            
+            dp[(l, r)] = 0
+            for i in range(l, r+1):
+                dp[(l, r)] = max(dp[(l, r)], nums[l-1]*nums[i]*nums[r+1] + dfs(l, i-1) + dfs(i+1, r))
+            return dp[(l, r)]
+                
+        nums = [1]+nums+[1]
+        dp = {}
+        return dfs(1, len(nums)-2)

problems/python3/coin-change-ii.py

@@ -0,0 +1,12 @@
+class Solution:
+    def change(self, amount: int, coins: List[int]) -> int:
+        dp = [0]*(amount+1)
+        dp[0] = 1
+        
+        coins.sort()
+        
+        for coin in coins:
+            for a in range(1, amount+1):
+                if a-coin<0: continue
+                dp[a] += dp[a-coin]
+        return dp[-1]

problems/python3/counting-bits.py

@@ -0,0 +1,9 @@
+class Solution:
+    def countBits(self, n: int) -> List[int]:
+        ans = [0]*(n+1)
+        offset = 1
+        
+        for i in range(1, n+1):
+            if offset*2==i: offset = offset*2
+            ans[i] = 1+ans[i-offset]
+        return ans

problems/python3/distinct-subsequences.py

@@ -0,0 +1,17 @@
+class Solution:
+    def numDistinct(self, s: str, t: str) -> int:
+        def dfs(i, j):
+            if (i, j) in visited: return visited[(i, j)]
+            
+            if j>=len(t): return 1
+            if i>=len(s): return 0
+            
+            if s[i]==t[j]:
+                visited[(i, j)] = dfs(i+1, j+1)+dfs(i+1, j)
+            else:
+                visited[(i, j)] = dfs(i+1, j)
+            return visited[(i, j)]
+            
+        visited = {}
+        dfs(0, 0)
+        return dfs(0, 0)

problems/python3/edit-distance.py

@@ -0,0 +1,37 @@
+"""
+dfs(i, j)
+i being the unprocessed index in word1.
+j, word2.
+
+MAIN LOGIC:
+if word1[i]==word2[j], no operation need, return dfs(i+1, j+1)
+if not, need 1 operation, so
+replace: dfs(i+1, j+1)
+insert: dfs(i, j+1)
+delete: dfs(i+1, j)
+
+BASE CASE:
+If both string are empty (i==N and j==M), no operation needed.
+If one string are empty, then the remain operation is the length of the non-empty one.
+"""
+class Solution:
+    def minDistance(self, word1: str, word2: str) -> int:
+        N = len(word1)
+        M = len(word2)
+        def dfs(i, j)->int:
+            if i==N and j==M: return 0
+            if i==N: return M-j
+            if j==M: return N-i
+            
+            if (i, j) in history:
+                return history[(i, j)]
+                
+            if word1[i]==word2[j]:
+                history[(i, j)] = dfs(i+1, j+1)
+            else:
+                history[(i, j)] = 1+min(dfs(i+1, j+1), dfs(i+1, j), dfs(i, j+1))
+            
+            return history[(i, j)]
+        
+        history = {}
+        return dfs(0, 0)

problems/python3/interleaving-string.py

@@ -0,0 +1,13 @@
+class Solution:
+    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:
+        def dfs(i, j):
+            if (i, j) in history: return False
+            if i+j==len(s3): return True
+            if i<len(s1) and s3[i+j]==s1[i] and dfs(i+1, j): return True
+            if j<len(s2) and s3[i+j]==s2[j] and dfs(i, j+1): return True
+            history.add((i, j))
+            return False
+        
+        if len(s1)+len(s2)!=len(s3): return False
+        history = set() #store the failed cases
+        return dfs(0, 0)

problems/python3/longest-increasing-path-in-a-matrix.py

@@ -0,0 +1,26 @@
+"""
+Time: O(MN) since the memo at most has MN index.
+Space: O(MN)
+"""
+class Solution:
+    def longestIncreasingPath(self, matrix: List[List[int]]) -> int:
+        def dfs(i0, j0):
+            if (i0, j0) in memo: return memo[(i0, j0)]
+            ans = 1
+            
+            for i, j in ((i0+1, j0), (i0-1, j0), (i0, j0+1),(i0, j0-1)):
+                if i<0 or i>=N or j<0 or j>=M: continue
+                if matrix[i][j]<=matrix[i0][j0]: continue
+                ans = max(ans, 1+dfs(i, j))
+            
+            memo[(i0, j0)] = ans
+            return ans
+            
+        N = len(matrix)
+        M = len(matrix[0])
+        memo = {}
+        ans = 0
+        for i in range(N):
+            for j in range(M):
+                ans = max(ans, dfs(i, j))
+        return ans

problems/python3/number-of-1-bits.py

@@ -0,0 +1,10 @@
+"""
+n = n&(n-1) will turn the right most 1 to 0.
+"""
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        ans = 0
+        while n>0:
+            n = n&(n-1)
+            ans += 1
+        return ans

problems/python3/regular-expression-matching.py

@@ -0,0 +1,24 @@
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        def dfs(i, j):
+            if (i, j) in cache: return cache[(i, j)]
+            if i>=M and j>=N: return True
+            if j>=N: return False
+            
+            match = i<M and (s[i]==p[j] or p[j]=='.')
+            
+            if j+1<N and p[j+1]=='*':
+                cache[(i, j)] = (match and dfs(i+1, j)) or dfs(i, j+2) #(use one or more p[j]) or (use zero p[j])
+                return cache[(i, j)]
+            
+            if match:
+                cache[(i, j)] = dfs(i+1, j+1)
+                return cache[(i, j)]
+            
+            cache[(i, j)] = False
+            return cache[(i, j)]
+        
+        cache = {}
+        M = len(s)
+        N = len(p)
+        return dfs(0, 0)

problems/python3/reverse-bits.py

@@ -0,0 +1,7 @@
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        res = 0
+        for i in range(32):
+            bit = (n >> i) & 1
+            res = res | (bit << (31 - i))
+        return res

problems/python3/single-number.py

@@ -0,0 +1,15 @@
+"""
+^ (XOR)
+The same will be 0
+0^0 = 0
+1^1 = 0
+
+Different will be 1
+1^0 = 1
+0^1 = 1
+"""
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        ans = 0
+        for num in nums: ans ^= num
+        return ans

problems/python3/target-sum.py

@@ -0,0 +1,25 @@
+"""
+Time: O(NS), S is sum(nums), N is len(nums). This is the max possible number of element in "history". Which will be lesser than 2^N.
+Space: O(NS)
+"""
+class Solution:
+    def findTargetSumWays(self, nums: List[int], target: int) -> int:
+        def dfs(i, curr):
+            #cache
+            if (i, curr) in history:
+                return history[(i, curr)]
+            
+            #ending condition
+            if i==len(nums):
+                if curr==target:
+                    history[(i, curr)] = 1
+                else:
+                    history[(i, curr)] = 0
+                return history[(i, curr)]
+            
+            history[(i, curr)] = dfs(i+1, curr+nums[i])+dfs(i+1, curr-nums[i])
+            return history[(i, curr)]
+        
+        ans = 0
+        history = {}
+        return dfs(0, 0)