no message

Author: Chris Wu

problems/delete-operation-for-two-strings.py

@@ -0,0 +1,28 @@
+class Solution(object):
+    def minDistance(self, word1, word2):
+        N = len(word1)
+        M = len(word2)
+        
+        dp = [[float('inf') for _ in xrange(M+1)] for _ in xrange(N+1)]
+        
+        
+        for i in xrange(1, N+1): dp[i][0] = i #need i deletion for word1[0:i-1] to be ""
+        for j in xrange(1, M+1): dp[0][j] = j #need i deletion for word1[0:j-1] to be ""
+        dp[0][0] = 0
+        
+        for i in xrange(1, N+1):
+            for j in xrange(1, M+1):
+			    #dp[i][j] := min operation count for dp[0:i] and dp[0:j-1] to be the same.
+                
+				#if char at i-1 and j-1 are the same, no deletion needed.
+                if word1[i-1]==word2[j-1]:
+                    dp[i][j] = min(dp[i][j], dp[i-1][j-1])
+                
+                dp[i][j] = min(dp[i][j], dp[i][j-1]+1) #remove char on word2[j-1]
+                dp[i][j] = min(dp[i][j], dp[i-1][j]+1) #remove char on word1[i-1]
+            return dp[N][M]
+
+"""
+Time: O(MN)
+Space: O(MN)
+"""

problems/filling-bookcase-shelves.py

@@ -0,0 +1,25 @@
+"""
+dp[i] := min height when storing books 0~i
+for each j try to add a new line at i, see the min height.
+
+Time: O(N^2)
+Space: O(N)
+"""
+class Solution(object):
+    def minHeightShelves(self, books, shelf_width):
+        N = len(books)
+        dp = [float('inf')]*N
+        
+        for j in xrange(N):
+            w = 0
+            h = 0
+            for i in xrange(j, -1, -1):
+                w+=books[i][0]
+                if w>shelf_width: break
+                
+                h = max(h, books[i][1])
+                if i==0:
+                    dp[j] = min(dp[j], h)
+                else:
+                    dp[j] = min(dp[j], dp[i-1]+h)
+        return dp[-1]

problems/longest-increasing-subsequence.py

@@ -0,0 +1,34 @@
+from bisect import bisect_left
+
+class Solution(object):
+    def lengthOfLIS(self, nums):
+        dp = [1 for _ in nums]
+        
+        for i in xrange(1, len(nums)):
+            for j in xrange(i-1, -1, -1):
+                if nums[j]<nums[i]:
+                    dp[i] = max(dp[i], dp[j]+1)
+        
+        return max(dp)
+"""
+Time: O(N^2)
+Spacce: O(N)
+"""
+
+
+class Solution(object):
+    def lengthOfLIS(self, nums):
+        dp = []
+
+        for n in nums:
+            i = bisect_left(dp, n)
+            if i==len(dp):
+                dp.append(n)
+            else:
+                dp[i] = n
+                
+        return len(dp)
+
+"""
+dp[i] := the smallest ending number that has length i+1
+"""

problems/longest-string-chain.py

@@ -0,0 +1,68 @@
+import collections
+
+"""
+DP
+
+Time: O(NLogN)+O(NSS),
+
+Where N is the number of words and S is the length of each word. (S<=16)
+NLogN is for sorting words. NSS is for the double for-loop.
+
+Space: O(NS)
+"""
+class Solution(object):
+    def longestStrChain(self, words):
+        dp = {}
+        
+        for word in sorted(words, key=len):
+            dp[word] = 1
+            for i in xrange(len(word)):
+                posible_predecessor = word[:i]+word[i+1:]
+                dp[word] = max(dp.get(word), dp.get(posible_predecessor, 0)+1)
+                
+        return max(dp.values())
+
+"""
+Recursive
+
+Time: O(N^2 x SS),
+Basically for every word, check if there are predecessor exist in the words.
+If so, keep looking. Until we find the smallest predecessor.
+S is the length of each word. isPredecessor takes SS.
+
+Space: O(NS)
+"""
+class Solution(object):
+    def longestStrChain(self, words):
+        def isPredecessor(word, word2):
+            if not word or not word2: return False
+            for i in xrange(len(word)):
+                if word[:i]+word[i+1:]==word2:
+                    return True
+            return False
+
+        def shortestPredecessor(word):
+            if word in history: return history[word]
+            shortest_predecessor = word
+            for word2 in word_group[len(word)-1]:
+                if isPredecessor(word, word2):
+                    sp = shortestPredecessor(word2)
+                    if len(sp)<len(shortest_predecessor): shortest_predecessor = sp
+            history[word] = shortest_predecessor
+            return history[word]
+
+        word_group = collections.defaultdict(list)
+        ans = 1
+        history = {} # classic memorization for the recursion.
+        
+        for word in words:
+            word_group[len(word)].append(word)
+        
+        for l in xrange(max(word_group.keys()), 0, -1):
+            if l<ans: break # no need to check since the l is already too small
+            for word in word_group[l]:
+                ans = max(ans, l-len(shortestPredecessor(word))+1)
+        
+        return ans
+
+

problems/number-of-longest-increasing-subsequence.py

@@ -0,0 +1,29 @@
+class Solution(object):
+    def findNumberOfLIS(self, nums):
+        L = [1]*len(nums) #LIS
+        C = [1]*len(nums)
+        
+        for i in xrange(len(nums)):
+            for j in xrange(i):
+                if nums[i]>nums[j]:
+                    if L[j]+1==L[i]:
+                        # If L[j]+1==L[i], it means that the combination of L[j] can simply append nums[i] and reach L[i]
+                        # So add the C[j] to C[i]
+                        C[i] += C[j]
+                    elif L[j]+1>L[i]:
+                        # If L[j]+1==L[i], it means that the combination of L[j] can simply append nums[i] and exceed L[i]
+                        # So update L[i] to L[j]+1 and C[i] to C[j]
+                        L[i] = L[j]+1
+                        C[i] = C[j]
+        
+        max_length = max(L)
+        max_length_count = 0
+        for i, count in enumerate(C):
+            if L[i]==max_length:
+                max_length_count+=count
+        return max_length_count
+
+"""
+Time: O(N^2)
+Spance: O(1)
+"""

problems/palindrome-partitioning.py

@@ -11,4 +11,4 @@ def search(s, pal_list):
                     search(s[i:], pal_list+[s[:i]])
         opt = []
         search(S, [])
-        return opt
+        return opt

problems/unique-binary-search-trees.py

@@ -0,0 +1,14 @@
+
+# Implement from https://www.youtube.com/watch?v=GgP75HAvrlY
+class Solution(object):
+    def numTrees(self, n):
+        dp = [1, 1, 2]
+        
+        if n<=2: return dp[n]
+        
+        for i in xrange(3, n+1):
+            dp.append(0)
+            for root in xrange(1, i+1):
+                dp[i] += dp[root-1]*dp[i-root]
+                
+        return dp[n]