255

Author: RealHacker

253_meeting_room_ii/meeting_room_ii.py

@@ -0,0 +1,32 @@
+# Definition for an interval.
+# class Interval(object):
+#     def __init__(self, s=0, e=0):
+#         self.start = s
+#         self.end = e
+import operator
+class Solution(object):
+    def minMeetingRooms(self, intervals):
+        """
+        :type intervals: List[Interval]
+        :rtype: int
+        """
+        if not intervals:
+            return 0
+        pairs = []
+        for interval in intervals:
+            pairs.append((interval.start, 1))
+            pairs.append((interval.end, -1))
+        # sort first by time value, and make sure endtime (-1) comes before starttime(1)
+        pairs.sort()
+        
+        
+        max_depth = 0
+        depth = 0
+        for _, pos in pairs:
+            if pos>0:
+                depth += 1
+                if depth > max_depth:
+                    max_depth = depth
+            else:
+                depth -= 1
+        return max_depth

253_meeting_room_ii/problem.txt

@@ -0,0 +1,5 @@
+Given an array of meeting time intervals consisting of start and end times [[s1,e1],[s2,e2],...] (si < ei), find the minimum number of conference rooms required.
+
+For example,
+Given [[0, 30],[5, 10],[15, 20]],
+return 2.

254_factor_combinations/factor_combinations.py

@@ -0,0 +1,25 @@
+import math
+class Solution(object):
+    def getFactors(self, n):
+        """
+        :type n: int
+        :rtype: List[List[int]]
+        """
+        self.memo = {}
+        return self.recurse(n)
+        
+    def recurse(self, n):
+        if n in self.memo:
+            return self.memo[n]
+        result = []
+        sqrtn = int(math.sqrt(n))+1
+        for i in range(2, sqrtn):
+            if n%i==0:
+                result.append([i, n/i])
+                sub = self.recurse(n/i)
+                for lst in sub:
+                    if lst[0]>=i:
+                        result.append([i]+lst)
+        self.memo[n] = result
+        return result
+                

254_factor_combinations/problem.txt

@@ -0,0 +1,33 @@
+Numbers can be regarded as product of its factors. For example,
+
+8 = 2 x 2 x 2;
+  = 2 x 4.
+
+Note: 
+Each combination's factors must be sorted ascending, for example: The factors of 2 and 6 is [2, 6], not [6, 2].
+You may assume that n is always positive.
+Factors should be greater than 1 and less than n.
+Examples: 
+input: 1
+output: 
+[]
+input: 37
+output: 
+[]
+input: 12
+output:
+[
+  [2, 6],
+  [2, 2, 3],
+  [3, 4]
+]
+input: 32
+output:
+[
+  [2, 16],
+  [2, 2, 8],
+  [2, 2, 2, 4],
+  [2, 2, 2, 2, 2],
+  [2, 4, 4],
+  [4, 8]
+]

255_verify_preorder_sequence/problem.txt

@@ -0,0 +1,6 @@
+Given an array of numbers, verify whether it is the correct preorder traversal sequence of a binary search tree.
+
+You may assume each number in the sequence is unique.
+
+Follow up:
+Could you do it using only constant space complexity?

255_verify_preorder_sequence/verify.py

@@ -0,0 +1,11 @@
+class Solution(object):
+    def verifyPreorder(self, preorder):
+        stack = []
+        lower = -1 << 31
+        for x in preorder:
+            if x < lower:
+                return False
+            while stack and x > stack[-1]:
+                lower = stack.pop()
+            stack.append(x)
+        return True

255_verify_preorder_sequence/verify_TLE.py

@@ -0,0 +1,19 @@
+class Solution(object):
+    def verifyPreorder(self, preorder):
+        """
+        :type preorder: List[int]
+        :rtype: bool
+        """
+        if len(preorder)<2:
+            return True
+        root = preorder[0]
+        breakpoint = -1
+        for i in range(1, len(preorder)):
+            if preorder[i]>root:
+                if breakpoint<0:
+                    breakpoint = i
+            if preorder[i]<root and breakpoint>0:
+                return False
+        if breakpoint <0:
+            breakpoint = len(preorder)
+        return self.verifyPreorder(preorder[1:breakpoint]) and self.verifyPreorder(preorder[breakpoint:]) 

255_verify_preorder_sequence/verify_take_2.py

@@ -0,0 +1,38 @@
+class Solution(object):
+    def verifyPreorder(self, preorder):
+        """
+        :type preorder: List[int]
+        :rtype: bool
+        """
+        if len(preorder)<2:
+            return True
+        roots = [] # contains tuples (node, direction) where direction 0 for left and 1 for right
+        current = preorder[0]
+        for num in preorder[1:]:
+            if num < current:
+                for i in range(len(roots)-1, -1, -1):
+                    val, dir = roots[i]
+                    if dir==1: # right branch
+                        if num < val: 
+                            return False
+                        else:
+                            break
+                roots.append((current, 0))
+                current = num
+            else:
+                top = -1
+                for i in range(len(roots)-1, -1, -1):
+                    val, dir = roots[i]
+                    if dir==0:
+                        if num < val:
+                            break
+                        else:
+                            top = i
+                if top < 0:
+                    roots.append((current, 1))
+                else:
+                    del roots[top+1:]
+                    roots[top] = (roots[top][0], 1)
+                current = num
+        return True
+