update

Author: wuduhren

problems/python3/letter-combinations-of-a-phone-number.py

@@ -0,0 +1,25 @@
+"""
+Time: O(4^N * N), there are around 4^N of combination. Each taking O(N) to form.
+Space: O(N). O(N) for recursion stack. O(N). O(N) for `combination`. O(N+N) ~= O(N).
+"""
+class Solution:
+    def letterCombinations(self, digits: str) -> List[str]:
+        def helper(i):
+            if i==len(digits):
+                ans.append(''.join(combination))
+                return
+            
+            for c in mapping[digits[i]]:
+                combination.append(c)
+                helper(i+1)
+                combination.pop()
+        
+        mapping = {'2': ('a', 'b', 'c'), '3': ('d', 'e', 'f'),
+            '4': ('g', 'h', 'i'), '5': ('j', 'k', 'l'), '6': ('m', 'n', 'o'),
+            '7': ('p', 'q', 'r', 's'), '8': ('t', 'u', 'v'), '9': ('w', 'x', 'y', 'z')}
+        
+        if not digits: return []
+        ans = []
+        combination = []
+        helper(0)
+        return ans

problems/python3/palindrome-partitioning.py

@@ -0,0 +1,64 @@
+"""
+`helper(i)` finds all the palindrome substring from i to j see if we can get an answer by recursively calling `helper(j+1)`.
+
+Time: O(2^N * N), for a string length S, there will be 2^N combination of substrings. For each substring, it will take O(N) to test if they are all palindrome.
+Space: O(N). `partition` will takes O(N) and recursion stack will also take O(N). O(N + N) ~= O(N)
+"""
+class Solution:
+    def partition(self, s: str) -> List[List[str]]:
+        def helper(i):
+            if i>=len(s):
+                ans.append(partition.copy())
+                return
+            
+            for j in range(i, len(s)):
+                if isPalindrome(i, j):
+                    partition.append(s[i:j+1])
+                    helper(j+1)
+                    partition.pop()
+
+        def isPalindrome(i, j):
+            while i<=j:
+                if s[i]!=s[j]: return False
+                i += 1
+                j -= 1
+            return True
+                
+        ans = []
+        partition = []
+        helper(0)
+        return ans
+
+"""
+If you look closely you can see that we execute `isPalindrome` on many repeated substrings.
+We can optimize this by storing the result in `dp` and reuse it.
+Since all the less difference i and j (shorter substring s[i:j+1]) will be process first in the `isPalindrome`.
+When checking if s[i:j+1] is a palindrome or not, we can simply check the if s[i]==s[j] and the previous result (dp[i+1][j-1])
+
+Time: O(2^N * N), The overall time complexity is the same, but isPalindrome is actually a lot faster.
+Space: O(N^2) for `dp`.
+"""
+class Solution:
+    def partition(self, s: str) -> List[List[str]]:
+        def helper(i):
+            if i>=N:
+                ans.append(partition.copy())
+                return
+            
+            for j in range(i, N):
+                if isPalindrome(i, j):
+                    partition.append(s[i:j+1])
+                    helper(j+1)
+                    partition.pop()
+
+        def isPalindrome(i, j):
+            dp[i][j] = i==j or (j-i==1 and s[i]==s[j]) or (s[i]==s[j] and dp[i+1][j-1]) #len==1 palindrome or len==2 palindrome or len>=3 palindrome
+            return dp[i][j]
+        
+        N = len(s)
+        ans = []
+        partition = []
+        dp = [[False]*N for _ in range(N)]
+
+        helper(0)
+        return ans

problems/python3/word-search.py

@@ -0,0 +1,27 @@
+class Solution:
+    def exist(self, board: List[List[str]], word: str) -> bool:
+        def helper(x, i, j):
+            if i<0 or i>=N or j<0 or j>=M: return False
+            if (i, j) in usedWords: return False
+            usedWords.add((i, j))
+            
+            if word[x]==board[i][j]:
+                if x==len(word)-1:
+                    return True
+                else:
+                    if helper(x+1, i+1, j): return True
+                    if helper(x+1, i, j+1): return True
+                    if helper(x+1, i-1, j): return True
+                    if helper(x+1, i, j-1): return True
+                    
+                    
+            usedWords.remove((i, j))
+            return False
+                    
+        usedWords = set()
+        N = len(board)
+        M = len(board[0])
+        for i in range(N):
+            for j in range(M):
+                if helper(0, i, j): return True
+        return False