no message

Author: wuduhren

problems/count-unique-characters-of-all-substrings-of-a-given-string.py

@@ -0,0 +1,18 @@
+class Solution(object):
+    def uniqueLetterString(self, s):
+        index = {}
+        ans = 0
+        for c in 'abcdefghijklmnopqrstuvwxyz':
+            index[c.upper()] = [-1, -1]
+        
+        # count the substring that s[j] is the unique letter
+        for k, c in enumerate(s):
+            i, j = index[c]
+            ans += (j-i) * (k-j)
+            index[c] = [j, k]
+        
+        # count the substring that s[j] is the unique letter, because last iteration did not count the last letter
+        for c in index:
+            i, j = index[c]
+            ans += (j-i) * (len(s)-j)
+        return ans

problems/decode-ways.py

@@ -0,0 +1,19 @@
+"""
+Time: O(N), due to the "memo", the time can reduce from O(2^N) to O(N).
+Space: O(N)
+"""
+class Solution(object):
+    def numDecodings(self, s):
+        def helper(s, i):
+            if (s, i) in memo: return memo[(s, i)]
+            if i>=len(s): return 1
+            if s[i]=='0': return 0
+            
+            count = 0
+            count += helper(s, i+1)
+            if len(s)-i>=2 and int(s[i:i+2])<=26: count += helper(s, i+2)
+            memo[(s, i)] = count
+            return count
+                
+        memo = {}
+        return helper(s, 0)

problems/longest-repeating-character-replacement.py

@@ -0,0 +1,23 @@
+"""
+Use the sliding window to iterate over the sub-strings. At the same time use a counter to track the count.
+The operation needed is the (length of the window) -  (count of the max count char in the counter)
+Since there are at most 26 char in the counter, `max(counter.values())` can be view as a O(1) operation.
+
+Time: O(N)
+Space: O(N)
+"""
+class Solution(object):
+    def characterReplacement(self, s, k):
+        counter = collections.Counter()
+        ans = 0
+        
+        l = 0
+        for r in xrange(len(s)):
+            counter[s[r]] += 1
+            
+            while r-l+1-max(counter.values())>k:
+                counter[s[l]] -= 1
+                l += 1
+                
+            ans = max(ans, r-l+1)
+        return ans

problems/maximum-product-subarray.py

@@ -0,0 +1,57 @@
+"""
+Time: O(N)
+Space: O(N)
+
+dp[i][0] := the maximum subarray product that includes nums[i]
+dp[i][1] := the minimum subarray product that includes nums[i]
+"""
+class Solution(object):
+    def maxProduct(self, nums):
+        if not nums: return 0
+        dp = [[float('-inf'), float('inf')] for _ in xrange(len(nums))]
+        
+        dp[0] = [nums[0], nums[0]]
+        ans = nums[0]
+        
+        for i in xrange(1, len(nums)):
+            if nums[i]==0:
+                dp[i][0] = 0
+                dp[i][1] = 0
+            elif nums[i]>0:
+                dp[i][0] = dp[i-1][0]*nums[i] if dp[i-1][0]>0 else nums[i]
+                dp[i][1] = dp[i-1][1]*nums[i] if dp[i-1][1]<=0 else nums[i]
+            else:
+                dp[i][0] = dp[i-1][1]*nums[i] if dp[i-1][1]<=0 else nums[i]
+                dp[i][1] = dp[i-1][0]*nums[i] if dp[i-1][0]>0 else nums[i]
+                
+            ans = max(ans, dp[i][0])
+            
+        return ans
+
+"""
+The above solution can further reduce the space complexity to O(1).
+"""
+class Solution(object):
+    def maxProduct(self, nums):
+        if not nums: return 0
+        
+        maxLast = nums[0]
+        minLast = nums[0]
+        ans = nums[0]
+        
+        for i in xrange(1, len(nums)):
+            if nums[i]==0:
+                newMax = 0
+                newMin = 0
+            elif nums[i]>0:
+                newMax = maxLast*nums[i] if maxLast>0 else nums[i]
+                newMin = minLast*nums[i] if minLast<=0 else nums[i]
+            else:
+                newMax = minLast*nums[i] if minLast<=0 else nums[i]
+                newMin = maxLast*nums[i] if maxLast>0 else nums[i]
+            
+            maxLast = newMax
+            minLast = newMin
+            ans = max(ans, maxLast)
+            
+        return ans

problems/maximum-units-on-a-truck.py

@@ -0,0 +1,17 @@
+class Solution(object):
+    def maximumUnits(self, boxTypes, truckSize):
+        sortedBox = []
+        ans = 0
+        
+        for count, units in boxTypes:
+            sortedBox.append((units, count))
+        
+        sortedBox.sort()
+        
+        while sortedBox and truckSize>0:
+            units, count = sortedBox.pop()
+            d = min(count, truckSize)
+            truckSize -= d
+            ans += d*units
+            
+        return ans

problems/pacific-atlantic-water-flow.py

@@ -0,0 +1,30 @@
+class Solution(object):
+    def pacificAtlantic(self, heights):
+        def bfs(q, ocian):
+            while q:
+                i0, j0 = q.popleft()
+                if (i0, j0) in ocian: continue
+                ocian.add((i0, j0))
+                
+                for i, j in [(i0+1, j0), (i0-1, j0), (i0, j0+1), (i0, j0-1)]:
+                    if i>=len(heights) or i<0 or j>=len(heights[0]) or j<0: continue
+                    if heights[i][j]>=heights[i0][j0]: q.append((i, j))
+                        
+        pacific = set()
+        altalantic = set()
+        q1 = collections.deque()
+        q2 = collections.deque()
+        
+        #add top, left to pacific
+        for j in xrange(len(heights[0])): q1.append((0, j))
+        for i in xrange(len(heights)): q1.append((i, 0))
+            
+        #add right, bottom to atalantic
+        for j in xrange(len(heights[0])): q2.append((len(heights)-1, j))
+        for i in xrange(len(heights)): q2.append((i, len(heights[0])-1))
+        
+        bfs(q1, pacific)
+        bfs(q2, altalantic)
+                        
+        return pacific.intersection(altalantic)
+                

problems/palindromic-substrings.py

@@ -0,0 +1,61 @@
+"""
+dp[i][j] := if s[i:j+1] is palindrome.
+1. all length==1 string is palindrome.
+2. all length==2 string is palindrome if two are the same.
+3. all length>=3 string is palindrome if the outer most two char is the same and have an palindrome string inside.
+
+Time: O(N^2)
+Space: 0(N^2)
+"""
+class Solution(object):
+    def countSubstrings(self, s):
+        N = len(s)
+        dp = [[False]*N for _ in xrange(N)]
+        ans = 0
+        
+        #1
+        for i in xrange(N):
+            dp[i][i] = True
+            ans += 1
+        
+        #2
+        for i in xrange(N-1):
+            if s[i]==s[i+1]:
+                dp[i][i+1] = True
+                ans += 1
+        
+        #3
+        for l in xrange(3, N+1):
+            for i in xrange(N):
+                j = i+l-1
+                if j>=N: continue
+                if dp[i+1][j-1] and s[i]==s[j]:
+                    dp[i][j] = True
+                    ans += 1
+        return ans
+
+"""
+Iterate through the string, expand around each character.
+Like this solution more since it is more intuitive.
+
+Time: O(N^2)
+Space: O(1)
+"""
+class Solution(object):
+    def countSubstrings(self, s):
+        def count(l, r, N):
+            count = 0
+            
+            while l>=0 and r<N and s[l]==s[r]:
+                count += 1
+                l = l-1
+                r = r+1
+            return count
+                
+        N = len(s)
+        ans = 0
+        
+        for i in xrange(N):
+            ans += count(i, i+1, N) #count even length palindrome
+            ans += count(i, i, N) #count odd length palindrome
+        return ans

problems/search-suggestions-system.py

@@ -1,8 +1,66 @@
+"""
+Time: O(NLogN) for sorting the products, N is the number of product. O(SLogN) for search, S is the number of char of the searchWord.
+Space: O(1)
+
+Sort the products then binary search it.
+"""
+class Solution(object):
+    def suggestedProducts(self, products, searchWord):
+        def search(products, word):
+            l = 0
+            r = len(products)-1
+            n = len(word)
+            
+            while l<=r:
+                m = (l+r)/2
+                if products[l].startswith(word): return getTop3(products, word, l)
+                if products[r].startswith(word): return getTop3(products, word, r)
+                if products[m].startswith(word): return getTop3(products, word, m)
+                
+                if products[m][:n]>word:
+                    r = m-1
+                else:
+                    l = m+1
+                
+            return []
+        
+        def getTop3(products, word, i):
+            suggestion = []
+            
+            while i-1>=0 and  products[i-1].startswith(word):
+                i -= 1
+            
+            for j in xrange(i, min(len(products), i+3)):
+                if not products[j].startswith(word): break
+                suggestion.append(products[j])
+            return suggestion
+        
+        
+        ans = []
+        products.sort()
+        
+        currSearchWord = ''
+        for c in searchWord:
+            currSearchWord += c
+            ans.append(search(products, currSearchWord))
+            
+        return ans
+
+
+        
+"""
+Time: O(M) + O(S^2) ~= O(M). M is the number of char in products. S is number of char of a searchWord.
+O(M) to build trie. O(len(prefix)) (~= O(S/2)) to get to the prefix node, and it will perform S time. O(1) to get top 3.
+Space: O(M)
+
+Use Trie to store the relation and search it.
+"""
 class Node(object):
     def __init__(self, c):
         self.c = c
         self.nexts = {}
 
+
 class Solution(object):
     def suggestedProducts(self, products, searchWord):
         ans = []
@@ -37,4 +95,5 @@ def helper(prefix, node):
 
         top3 = []
         helper(prefix, node)
-        return top3
+        return top3
+

problems/set-matrix-zeroes.py

@@ -0,0 +1,35 @@
+"""
+Space: O(1)
+Time: O(N^2)
+
+Mark matrix[i][0] as string if all matrix[i][?] needs to be set to 0.
+Mark matrix[0][j] as string if all matrix[?][j] needs to be set to 0.
+There is an edje case where matrix[0][0] cannot represent for row and col at the same time.
+So we need an additional variable, firstRowToZero.
+
+Explanation: https://www.youtube.com/watch?v=T41rL0L3Pnw
+"""
+class Solution(object):
+    def setZeroes(self, matrix):
+        firstRowToZero = False
+        
+        for i in xrange(len(matrix)):
+            for j in xrange(len(matrix[0])):
+                if matrix[i][j]==0:
+                    if i!=0:
+                        matrix[i][0] = str(matrix[i][0])
+                    else:
+                        firstRowToZero = True
+                    matrix[0][j] = str(matrix[0][j])
+        
+        
+        for i in xrange(1, len(matrix)):
+            if type(matrix[i][0])!=type(''): continue
+            for j in xrange(len(matrix[0])): matrix[i][j] = 0
+        
+        for j in xrange(len(matrix[0])):
+            if type(matrix[0][j])!=type(''): continue
+            for i in xrange(len(matrix)): matrix[i][j] = 0
+        
+        if firstRowToZero:
+            for j in xrange(len(matrix[0])): matrix[0][j] = 0

problems/unique-paths.py

@@ -0,0 +1,9 @@
+class Solution(object):
+    def uniquePaths(self, m, n):
+        def factorial(n):
+            ans = 1
+            for i in xrange(1, n+1):
+                ans *= i
+            return ans
+        
+        return factorial((m-1)+(n-1))/(factorial(n-1)*factorial(m-1))