no message

Author: wuduhren

problems/amount-of-new-area-painted-each-day.py

@@ -0,0 +1,40 @@
+"""
+1. Build sorted records = [(position, index, isStart)...]
+2. Iterate through all positions and maintain a box with all the "index" of the records its position is in start ~ end
+3. The smallest index in the box is the actual one that is paiting.
+
+Time: O(NLogN+P), N is the count of paint. Sorting the records takes NLogN. P is the max position.
+Although there is a while loop when iterate through P, each record is only being iterated once.
+O(NLogN + P + NLogN) ~= O(NLogN + P)
+Space: O(N)
+"""
+from sortedcontainers import SortedList
+
+class Solution(object):
+    def amountPainted(self, paint):
+        ans = [0]*len(paint)
+        box = SortedList()
+        records = []
+        maxPos = float('-inf')
+        
+        #[1]
+        for i, (start, end) in enumerate(paint):
+            records.append((start, i, -1))
+            records.append((end, i, 1))
+            maxPos = max(maxPos, end)
+        
+        records.sort()
+        
+        #[2]
+        i = 0
+        for pos in xrange(maxPos+1):
+            while i<len(records) and records[i][0]==pos:
+                _, index, t = records[i]
+                if t==-1:
+                    box.add(index)
+                else:
+                    box.remove(index)
+                i += 1
+            
+            if box: ans[box[0]] += 1 #[3]
+        return ans

problems/basic-calculator-ii.py

@@ -0,0 +1,31 @@
+class Solution(object):
+    def calculate(self, s):
+        s += '+' #edge case, for last operation to be executed.
+        lastOperation = '+' #edge case, for the first currNum
+        operations = set(['+', '-', '*', '/'])
+        
+        stack = []
+        currNum = 0
+
+        for c in s:
+            if c.isdigit():
+                currNum = currNum*10 + int(c)
+            elif c in operations:
+                if lastOperation=='+':
+                    stack.append(currNum)
+                    currNum = 0
+                elif lastOperation=='-':
+                    stack.append(-currNum)
+                    currNum = 0
+                elif lastOperation=='*':
+                    currNum = stack.pop() * currNum
+                    stack.append(currNum)
+                    currNum = 0
+                elif lastOperation=='/':
+                    currNum = stack.pop() / currNum
+                    if currNum<0: currNum += 1
+                    stack.append(currNum)
+                    currNum = 0
+                lastOperation = c
+        
+        return sum(stack)

problems/buildings-with-an-ocean-view.py

@@ -0,0 +1,16 @@
+"""
+Traverse from the right and keep track of the highest building.
+
+Time: O(N)
+Space: O(1)
+"""
+class Solution(object):
+    def findBuildings(self, heights):
+        ans = []
+        currMaxHeight = 0
+        for i in xrange(len(heights)-1, -1, -1):
+            h = heights[i]
+            if h>currMaxHeight: ans.append(i)
+            currMaxHeight = max(currMaxHeight, h)
+        
+        return reversed(ans)

problems/convert-binary-search-tree-to-sorted-doubly-linked-list.py

@@ -103,4 +103,28 @@ def inOrderTraverse(root):
 
         node = node.right
 
- 
+"""
+Time: O(N)
+Space: O(LogN)
+"""
+class Solution(object):
+    def treeToDoublyList(self, root):
+        def helper(node):
+            ll = rr = node
+            if node.left:
+                ll, lr = helper(node.left)
+                node.left = lr
+                lr.right = node
+            
+            if node.right:
+                rl, rr = helper(node.right)
+                node.right = rl
+                rl.left = node
+            
+            return ll, rr
+        
+        if not root: return root
+        left, right = helper(root)
+        right.right = left
+        left.left = right
+        return left

problems/custom-sort-string.py

@@ -0,0 +1,20 @@
+"""
+Take a look at the char in s.
+For the char that is in the order, rearrange them to sortedChars with respect to the "order".
+For the char that is in not the order, put them in postString.
+"""
+class Solution(object):
+    def customSortString(self, order, s):
+        sortedChars = ''
+        counter = collections.Counter(s)
+        for c in order:
+            if c in order:
+                sortedChars += c*counter[c]
+        
+        orderSet = set(order)
+        postString = ''
+        for c in s:
+            if c not in orderSet:
+                postString += c
+        
+        return sortedChars+postString

problems/dot-product-of-two-sparse-vectors.py

@@ -0,0 +1,16 @@
+class SparseVector:
+    def __init__(self, nums):
+        self.indices = set()
+        self.values = {}
+        
+        for i, n in enumerate(nums):
+            if n!=0:
+                self.indices.add(i)
+                self.values[i] = n
+                
+    def dotProduct(self, vec):
+        products = 0
+        indices = self.indices.intersection(vec.indices)
+        for i in indices:
+            products += self.values[i]*vec.values[i]
+        return products

problems/find-all-possible-recipes-from-given-supplies.py

@@ -0,0 +1,33 @@
+"""
+Use Topological Sort
+1. Build an adj list and inbound.
+2. Starts from supplies topologically traverse the map.
+3. For each node popping up, if it is in recipes, add it to ans.
+
+Time: O(N), N is the number of "nodes" (ingredients+recipes)
+Space: O(N).
+"""
+class Solution(object):
+    def findAllRecipes(self, recipes, ingredients, supplies):
+        N = len(recipes)
+        adj = collections.defaultdict(list)
+        inbounds = collections.Counter()
+        q = collections.deque(supplies)
+        recipeSet = set(recipes)
+        ans = []
+        
+        for i, recipe in enumerate(recipes):
+            for ingredient in ingredients[i]:
+                adj[ingredient].append(recipe)
+                inbounds[recipe] += 1
+        
+        while q:
+            node = q.popleft()
+            
+            if node in recipeSet: ans.append(node)
+            
+            for nei in adj[node]:
+                inbounds[nei] -= 1
+                if inbounds[nei]==0: q.append(nei)
+        
+        return ans

problems/k-closest-points-to-origin.py

@@ -12,4 +12,120 @@ def kClosest(self, points, k):
             else:
                 heapq.heappush(h, (-d, x, y))
 
-        return [(x, y) for _, x, y in h]
+        return [(x, y) for _, x, y in h]
+
+
+"""
+1. Process `points` into `distances`.
+
+2. Binary search the "distance". For every distance:
+Split the elements in `distances` by distance
+Put the ones smaller to smaller.
+Put the ones larger to larger.
+If len(smaller)<=k, then all the elements in the smaller must belong to the `ans`, do the same thing to the larger.
+Else we ignore the larger and do the same thing to the smaller again.
+
+Time: O(N)
+The binary search range in average is N, N/2, N/4... = 2N
+Space: O(N)
+"""
+class Solution(object):
+    def kClosest(self, points, K):
+        #[1]
+        maxD = float('-inf')
+        minD = float('inf')
+        distances = []
+        for x, y in points:
+            distance = ((x**2+y**2)**0.5)
+            distances.append((distance, x, y))
+            maxD = max(maxD, distance)
+            minD = min(minD, distance)
+        
+        #[2]
+        ans = []
+        smaller = []
+        larger = []
+        while K>0:
+            #split distances into smaller and larger
+            distance = (maxD+minD)/2
+            for d, x, y in distances:
+                if d<=distance:
+                    smaller.append((d, x, y))
+                else:
+                    larger.append((d, x, y))
+            
+            if len(smaller)<=K:
+                ans += smaller
+                K -= len(smaller)
+                distances = larger
+                minD = distance
+                larger = []
+                smaller = []
+            else:
+                distances = smaller
+                maxD = distance
+                larger = []
+                smaller = []
+        
+        return [(x, y) for _, x, y in ans]
+
+
+
+"""
+Quick Select
+Time: O(N)
+Space: O(N), can be optimize to O(1).
+"""
+class Solution(object):
+    def kClosest(self, points, K):
+		"""
+		Start State:
+		i = s #next element after "SSS"s
+		t = s #unprocessed elements
+		j = e #next element after "LLLL"s
+
+		SSSPP?????LLL
+		i t   j
+
+		End State:
+		SSSPPPPPLLLLL
+		i   jt
+		"""
+        def quickSelect(distances, s, e, k):
+
+            pivot = distances[(s+e)/2][0]
+            i = s
+            j = e
+            t = s
+            
+            while t<=j:
+                if pivot<distances[t][0]:
+                    distances[t], distances[j] = distances[j], distances[t]
+                    j -= 1
+                elif pivot>distances[t][0]:
+                    distances[t], distances[i] = distances[i], distances[t]
+                    i += 1
+                    t += 1
+                else:
+                    t += 1
+            
+            if i-s>=k:
+                return quickSelect(distances, s, i, k)
+            elif j-s+1>=k:
+                return pivot
+            else:
+                return quickSelect(distances, t, e, k-(t-s))
+
+        distances = []
+        for x, y in points:
+            distance = ((x**2+y**2)**0.5)
+            distances.append((distance, x, y))
+        
+        kthSmallestDistance = quickSelect(distances, 0, len(distances)-1, K)
+        
+        ans = []
+        for d, x, y in distances:
+            if len(ans)==K: break
+            if d<=kthSmallestDistance: ans.append((x, y))
+        
+        return ans

problems/longest-increasing-path-in-a-matrix.py

@@ -0,0 +1,31 @@
+class Solution(object):
+    def longestIncreasingPath(self, matrix):
+        def getLongest(i, j):
+            if (i, j) in longest: return longest[(i, j)]
+            l = 1
+
+            #call getLongest to the neighbors that are larger than itself.
+            if i+1<M and matrix[i][j]<matrix[i+1][j]:
+                l = max(l, 1+getLongest(i+1, j))
+            if i-1>=0 and matrix[i][j]<matrix[i-1][j]:
+                l = max(l, 1+getLongest(i-1, j))
+            if j+1<N and matrix[i][j]<matrix[i][j+1]:
+                l = max(l, 1+getLongest(i, j+1))
+            if j-1>=0 and matrix[i][j]<matrix[i][j-1]:
+                l = max(l, 1+getLongest(i, j-1))
+            
+            longest[(i, j)] = l
+            self.ans = max(self.ans, l)
+            return l
+
+        M = len(matrix)
+        N = len(matrix[0])
+        
+        longest = {}
+        self.ans = float('-inf')
+        
+        for i in xrange(M):
+            for j in xrange(N):
+                getLongest(i, j)
+                
+        return self.ans