no message

Author: wuduhren

problems/binary-subarrays-with-sum.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def numSubarraysWithSum(self, nums, goal):
+        #number of subarrays with sum at most "goal"
+        def atMost(goal):
+            ans = 0
+            total = 0
+            i = 0
+            
+            for j, num in enumerate(nums):
+                if num==1: total += 1
+                
+                while i<len(nums) and total>goal:
+                    if nums[i]==1: total -= 1
+                    i += 1
+                
+                ans += j-i+1 #number of subarrays that can generate from nums[i~j]
+            return ans
+        
+        return atMost(goal)-atMost(goal-1) if goal>0 else atMost(goal)

problems/coloring-a-border.py

@@ -0,0 +1,43 @@
+"""
+A node is on the "border" if 
+1. It is on the actual border of the grid.
+Or
+2. Any of its neighbor has different color.
+
+BFS the grid starting from (row, col), if the node "isBorder" add it to nodesToColor.
+Color the nodes in the nodesToColor.
+
+Time: O(N)
+Space: O(N)
+"""
+class Solution(object):
+    def colorBorder(self, grid, row, col, color):
+        def isValid(i, j):
+            return i>=0 and j>=0 and i<len(grid) and j<len(grid[0])
+        
+        def isBorder(i, j, color):
+            if i==0 or i==len(grid)-1 or j==0 or j==len(grid[0])-1: return True
+            if any(grid[iNei][jNei]!=color for iNei, jNei in [(i+1, j), (i-1, j), (i, j+1), (i, j-1)]): return True
+            return False
+            
+        q = collections.deque([(row, col)])
+        nodesToColor = []
+        visited = set()
+        
+        while q:
+            i, j = q.popleft()
+            
+            if not isValid(i, j): continue
+            if grid[i][j]!=grid[row][col]: continue
+            if (i, j) in visited: continue
+            visited.add((i, j))
+            
+            if isBorder(i, j, grid[row][col]): nodesToColor.append((i, j))
+            
+            for iNext, jNext in [(i+1, j), (i-1, j), (i, j+1), (i, j-1)]:
+                q.append((iNext, jNext))
+        
+        for i, j in nodesToColor:
+            grid[i][j] = color
+        
+        return grid

problems/count-number-of-nice-subarrays.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def numberOfSubarrays(self, nums, K):
+        def atMost(k):
+            oddCount = 0
+            ans = 0
+            i = 0
+            
+            for j in xrange(len(nums)):
+                if nums[j]%2!=0: oddCount += 1
+                
+                while oddCount>k:
+                    if nums[i]%2!=0: oddCount -= 1
+                    i += 1
+                
+                ans += j-i+1
+            
+            return ans
+        
+        return atMost(K)-atMost(K-1)

problems/delete-duplicate-folders-in-system.py

@@ -4,17 +4,13 @@ def __init__(self, val):
         self.key = None
         self.children = {}
 
-
 class Solution(object):
     def deleteDuplicateFolder(self, paths):
         def setKey(node):
-            if not node.children:
-                node.key = node.val
-            else:
-                node.key = ''
-                for c in sorted(node.children.keys()):
-                    setKey(node.children[c])
-                    node.key += node.children[c].val + '|' + node.children[c].key + '|'
+            node.key = ''
+            for c in sorted(node.children.keys()): #need to be sorted. so when child structs are the same, we won't generate different key from different iteration order.
+                setKey(node.children[c])
+                node.key += node.children[c].val + '|' + node.children[c].key + '|' #generate a key for each node. only considering its children structure. (see the "identical" definition, it does not consider the val of the node itself.)
 
             keyCount[node.key] += 1
 

problems/fruit-into-baskets.py

@@ -44,3 +44,26 @@ def totalFruit(self, tree):
             counter = max(counter, i-start+1)
             mark[t] = i
         return counter
+
+
+"""
+Find the length of longest subarray that at most has 2 unique number.
+"""
+class Solution(object):
+    def totalFruit(self, fruits):
+        ans = 0
+        uniqueFruits = 0
+        i = 0
+        counter = collections.Counter()
+        
+        for j, fruit in enumerate(fruits):
+            counter[fruit] += 1
+            if counter[fruit]==1: uniqueFruits += 1
+            
+            while uniqueFruits>2:
+                counter[fruits[i]] -= 1
+                if counter[fruits[i]]==0: uniqueFruits -= 1
+                i += 1
+            
+            ans = max(ans, j-i+1)
+        return ans

problems/max-consecutive-ones-iii.py

@@ -0,0 +1,15 @@
+class Solution(object):
+    def longestOnes(self, nums, k):
+        ans = 0
+        zeroCount = 0
+        i = 0
+        
+        for j, num in enumerate(nums):
+            if num==0: zeroCount += 1
+            
+            while zeroCount>k:
+                if nums[i]==0: zeroCount -= 1
+                i += 1
+            ans = max(ans, j-i+1)
+        
+        return ans

problems/minimum-knight-moves.py

@@ -0,0 +1,30 @@
+# Bidirectional BFS
+class Solution(object):
+    def minKnightMoves(self, x, y):
+        offsets = [(1, 2), (2, 1), (2, -1), (1, -2), (-1, -2), (-2, -1), (-2, 1), (-1, 2)]
+        q1 = collections.deque([(0, 0)])
+        q2 = collections.deque([(x, y)])
+        steps1 = {(0, 0): 0} #steps needed starting from (0, 0)
+        steps2 = {(x, y): 0} #steps needed starting from (x,y)
+        
+        while q1 and q2:
+            i1, j1 = q1.popleft()
+            if (i1, j1) in steps2: return steps1[(i1, j1)]+steps2[(i1, j1)]
+            
+            i2, j2 = q2.popleft()
+            if (i2, j2) in steps1: return steps1[(i2, j2)]+steps2[(i2, j2)]
+            
+            for ox, oy in offsets:
+                nextI1 = i1+ox
+                nextJ1 = j1+oy
+                if (nextI1, nextJ1) not in steps1:
+                    q1.append((nextI1, nextJ1))
+                    steps1[(nextI1, nextJ1)] = steps1[(i1, j1)]+1
+                
+                nextI2 = i2+ox
+                nextJ2 = j2+oy
+                if (nextI2, nextJ2) not in steps2:
+                    q2.append((nextI2, nextJ2))
+                    steps2[(nextI2, nextJ2)] = steps2[(i2, j2)]+1
+                
+        return float('inf')

problems/number-of-substrings-containing-all-thre.py

@@ -0,0 +1,22 @@
+class Solution(object):
+    def numberOfSubstrings(self, s):
+        #number of subarrays that at most have k unique char
+        def atMost(k):
+            counter = collections.Counter()
+            uniqueCount = 0
+            ans = 0
+            i = 0
+            
+            for j, c in enumerate(s):
+                counter[c] += 1
+                if counter[c]==1: uniqueCount += 1
+
+                while uniqueCount>k:
+                    counter[s[i]] -= 1
+                    if counter[s[i]]==0: uniqueCount-= 1
+                    i += 1
+                ans += j-i+1
+            return ans
+        
+        n = len(s)
+        return atMost(3) - atMost(2)

problems/replace-the-substring-for-balanced-string.py

@@ -0,0 +1,15 @@
+class Solution(object):
+    def balancedString(self, s):
+        n = len(s)
+        counter = collections.Counter(s)
+        i = 0
+        ans = n
+        
+        for j, c in enumerate(s):
+            counter[c] -= 1
+            
+            while i<n and all(counter[c]<=n/4 for c in 'QEWR'):
+                counter[s[i]] += 1
+                ans = min(ans, j-i+1)
+                i += 1
+        return ans

problems/subarrays-with-k-different-integers.py

@@ -0,0 +1,25 @@
+class Solution(object):
+    def subarraysWithKDistinct(self, nums, K):
+        #number of subarray of nums which have at most k different numbers.
+        def atMost(k):
+            i = 0
+            ans = 0
+            counter = collections.Counter()
+            uniqueCount = 0
+            
+            for j in xrange(len(nums)):
+                counter[nums[j]] += 1
+                if counter[nums[j]]==1: uniqueCount += 1
+                
+                while uniqueCount>k:
+                    counter[nums[i]] -= 1
+                    if counter[nums[i]]==0: uniqueCount -= 1
+                    i += 1
+                
+                # the logest subarray that ends at j is nums[i:j+1]
+                # nums[i:j+1] can produce j-i+1 subarrays that at most has k different number.
+                ans += j-i+1
+            
+            return ans
+        
+        return atMost(K)-atMost(K-1)