updates

Author: wuduhren

problems/python3/coin-change.py

@@ -0,0 +1,14 @@
+class Solution:
+    def coinChange(self, coins: List[int], amount: int) -> int:
+        dp = [float('inf')]*(amount+1)
+        dp[0] = 0
+        for coin in coins:
+            if coin<len(dp): dp[coin] = 1
+        
+        coins.sort()
+        
+        for i in range(1, amount+1):
+            for coin in coins:
+                if i-coin<0: break
+                dp[i] = min(dp[i], dp[i-coin]+1)
+        return dp[amount] if dp[amount]!=float('inf') else -1

problems/python3/decode-ways.py

@@ -0,0 +1,14 @@
+"""
+dp[i] := up until s[:i] how many possibility?
+"""
+class Solution:
+    def numDecodings(self, s: str) -> int:
+        mapping = set([str(n) for n in range(1, 27)])
+        N = len(s)
+        dp = [0]*(N+1)
+        dp[0] = 1
+        
+        for i in range(1, N+1):
+            if i-1>=0 and s[i-1] in mapping: dp[i] += dp[i-1]
+            if i-2>=0 and s[i-2:i] in mapping: dp[i] += dp[i-2]
+        return dp[-1]

problems/python3/house-robber-ii.py

@@ -0,0 +1,18 @@
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        if len(nums)<=1: return max(nums)
+        
+        N = len(nums)
+        dp = [[0, 0] for _ in range(N)]
+        dp[0][0] = nums[0]
+        
+        for i in range(1, N):
+            dp[i][0] = nums[i]+dp[i-1][1]
+            dp[i][1] = max(dp[i-1])
+        
+        dp2 = [[0, 0] for _ in range(N)]
+        for i in range(1, N):
+            dp2[i][0] = nums[i]+dp2[i-1][1]
+            dp2[i][1] = max(dp2[i-1])
+        
+        return max(dp[-1][1], dp2[-1][0])

problems/python3/house-robber.py

@@ -0,0 +1,17 @@
+"""
+Time: O(N)
+Space: O(N), can reduece to O(1).
+
+dp[i][0] := max revenue if house i robbed
+dp[i][1] := max revenue if house i not robbed
+"""
+class Solution:
+    def rob(self, nums: List[int]) -> int:
+        N = len(nums)
+        dp = [[0, 0] for _ in range(N)]
+        dp[0][0] = nums[0]
+        
+        for i in range(1, N):
+            dp[i][0] = nums[i]+dp[i-1][1]
+            dp[i][1] = max(dp[i-1])
+        return max(dp[-1])

problems/python3/longest-common-subsequence.py

@@ -0,0 +1,16 @@
+class Solution:
+    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
+        #dp[i][j] := number of longest Common Subsequence with text2[:i] and text2[:j]
+        
+        N = len(text1)
+        M = len(text2)
+        
+        dp = [[0]*(M+1) for _ in range(N+1)]
+        
+        for i in range(1, N+1):
+            for j in range(1, M+1):
+                if text1[i-1]==text2[j-1]:
+                    dp[i][j] = dp[i-1][j-1]+1
+                else:
+                    dp[i][j] = max(dp[i][j-1], dp[i-1][j])
+        return dp[-1][-1]

problems/python3/longest-palindromic-substring.py

@@ -0,0 +1,45 @@
+"""
+Time: O(N^2)
+Space: O(N^2)
+
+DP, TLE
+"""
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        ans = s[0]
+        N = len(s)
+        dp = [[False]*N for _ in range(N)]
+        
+        for i in range(N): dp[i][i] = True
+        
+        for l in range(2, N+1):
+            for i in range(N):
+                j = i+l-1
+                if j>=N: continue
+                dp[i][j] = s[i]==s[j] and (dp[i+1][j-1] or j-1<i+1)
+                if dp[i][j]: ans = s[i:j+1]
+        return ans
+
+
+"""
+Time: O(N^2)
+Space: O(1)
+"""
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        N = len(s)
+        ans = s[0]
+        
+        for i in range(N):
+            l, r = i, i
+            while l>=0 and r<N and s[l]==s[r]:
+                if r-l+1>len(ans): ans = s[l:r+1]
+                l -= 1
+                r += 1
+            
+            l, r = i, i+1
+            while l>=0 and r<N and s[l]==s[r]:
+                if r-l+1>len(ans): ans = s[l:r+1]
+                l -= 1
+                r += 1
+        return ans

problems/python3/maximum-product-subarray.py

@@ -0,0 +1,25 @@
+"""
+Time: O(N)
+Space: O(N), can be reduce to O(1)
+
+dp[i][0] := The max product from subarray that end with nums[i]
+dp[i][1] := The min product from subarray that end with nums[i]
+"""
+class Solution:
+    def maxProduct(self, nums: List[int]) -> int:
+        N = len(nums)
+        dp = [[1, 1] for _ in range(N+1)]
+        ans = float('-inf')
+        
+        for i in range(1, N+1):
+            dp[i][0] = dp[i][1] = nums[i-1]
+            
+            if nums[i-1]>0:
+                dp[i][0] = max(dp[i][0], nums[i-1]*dp[i-1][0])
+                dp[i][1] = min(dp[i][1], nums[i-1]*dp[i-1][1])
+            else:
+                dp[i][0] = max(dp[i][0], nums[i-1]*dp[i-1][1])
+                dp[i][1] = min(dp[i][1], nums[i-1]*dp[i-1][0])
+            ans = max(ans, dp[i][0])
+        
+        return ans

problems/python3/palindromic-substrings.py

@@ -0,0 +1,16 @@
+class Solution:
+    def countSubstrings(self, s: str) -> int:
+        def countPalindrome(l, r) -> int:
+            count = 0
+            while l>=0 and r<N and s[l]==s[r]:
+                count += 1
+                l -= 1
+                r += 1
+            return count
+        
+        N = len(s)
+        ans = 0
+        for i in range(N):
+            ans += countPalindrome(i, i)
+            ans += countPalindrome(i, i+1)
+        return ans

problems/python3/partition-equal-subset-sum.py

@@ -0,0 +1,20 @@
+"""
+Time: O(2^N), 2^0 + 2^1 + 2^2 + 2^3 + ... 2^(N-1) == 2^N-1
+Space: O(T), T is the sum of nums
+"""
+class Solution:
+    def canPartition(self, nums: List[int]) -> bool:
+        total = sum(nums)
+        if total%2!=0: return False
+        
+        target = total/2
+        possibleSum = set()
+        possibleSum.add(0)
+        for num in nums:
+            temp = set()
+            for p in possibleSum:
+                if p==target or p+num==target: return True
+                temp.add(p)
+                temp.add(p+num)
+            possibleSum = temp
+        return False

problems/python3/unique-paths.py

@@ -0,0 +1,11 @@
+class Solution:
+    def uniquePaths(self, m: int, n: int) -> int:
+        m = m-1 #number of steps need to move down
+        n = n-1 #number of steps need to move right
+        
+        #the total combination of m and n to sort will be (m+n)!
+        #since all "move down" are consider the same, we need to remove the repeatition of it sorting: m!.
+        #since all "move right" are consider the same, we need to remove the repeatition of it sorting: n!.
+        #(m+n)!/m!n!
+        
+        return math.factorial(m+n)//(math.factorial(m)*math.factorial(n))

problems/python3/word-break.py

@@ -0,0 +1,23 @@
+"""
+Time: O(N^2 * M). N is the length of the s. M is the number of word in wordDict.
+Note that s[i:i+len(word)]==word takes O(N) time.
+
+Space: O(N) for the recursion memory stack size.
+
+dfs(i) := will return starting at index i, if i to the end the string can be separated.
+"""
+class Solution:
+    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
+        def dfs(i):
+            if i==len(s): return True
+            if i in history and not history[i]: return False
+            
+            for word in wordDict:
+                if i+len(word)<=len(s) and s[i:i+len(word)]==word:
+                    history[i] = True
+                    if dfs(i+len(word)): return True
+            history[i] = False
+            return False
+        
+        history = {}
+        return dfs(0)