333

Author: RealHacker

314_binary_tree_vertical_order_traversal/problem.txt

@@ -0,0 +1,60 @@
+Given a binary tree, return the vertical order traversal of its nodes' values. (ie, from top to bottom, column by column).
+
+If two nodes are in the same row and column, the order should be from left to right.
+
+Examples:
+
+Given binary tree [3,9,20,null,null,15,7],
+   3
+  /\
+ /  \
+ 9  20
+    /\
+   /  \
+  15   7
+return its vertical order traversal as:
+[
+  [9],
+  [3,15],
+  [20],
+  [7]
+]
+Given binary tree [3,9,8,4,0,1,7],
+     3
+    /\
+   /  \
+   9   8
+  /\  /\
+ /  \/  \
+ 4  01   7
+return its vertical order traversal as:
+[
+  [4],
+  [9],
+  [3,0,1],
+  [8],
+  [7]
+]
+Given binary tree [3,9,8,4,0,1,7,null,null,null,2,5] (0's right child is 2 and 1's left child is 5),
+     3
+    /\
+   /  \
+   9   8
+  /\  /\
+ /  \/  \
+ 4  01   7
+    /\
+   /  \
+   5   2
+return its vertical order traversal as:
+[
+  [4],
+  [9,5],
+  [3,0,1],
+  [8,2],
+  [7]
+]
+Hide Company Tags Google Facebook
+Show Tags
+Show Similar Problems
+

314_binary_tree_vertical_order_traversal/traversal.py

@@ -0,0 +1,38 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+from collections import defaultdict
+import operator
+
+class Solution(object):
+    def verticalOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        if not root:
+            return []
+        self.cols = defaultdict(list)
+        self.recurse(root, 0, 0)
+        print self.cols
+        for k in self.cols:
+            vs = self.cols[k]
+            self.cols[k] = [v[1] for v in sorted(vs, key = operator.itemgetter(0))]
+        pairs = sorted(self.cols.items(), key=operator.itemgetter(0))
+        
+        return [pair[1] for pair in pairs]
+        
+    def recurse(self, node, n, depth):
+        # add the node itself into cols
+        self.cols[n].append((depth,node.val))
+        if node.left:
+            self.recurse(node.left, n-1, depth+1)
+        if node.right:
+            self.recurse(node.right, n+1, depth+1)
+        
+        
+        

320_generalized_abbreviation/abbreviation.py

@@ -0,0 +1,27 @@
+class Solution(object):
+    def generateAbbreviations(self, word):
+        """
+        :type word: str
+        :rtype: List[str]
+        """
+        self.memo = {}
+        ret =self.recurse(word)
+        return ret
+        
+    def recurse(self, word):
+        if not word:return [""]
+        if word in self.memo:
+            return self.memo[word]
+        results = [word]
+        for i in range(len(word)):
+            digits = str(i+1)
+            for j in range(len(word)-i):
+                suffixes = self.recurse(word[i+j+2:])
+                for suffix in suffixes:
+                    if i+j+1<len(word):
+                        results.append(word[:j]+digits+word[i+j+1]+suffix)
+                    else:
+                        results.append(word[:j]+digits)
+        self.memo[word] = results
+        return results
+                

320_generalized_abbreviation/problem.txt

@@ -0,0 +1,9 @@
+Write a function to generate the generalized abbreviations of a word.
+
+Example:
+Given word = "word", return the following list (order does not matter):
+["word", "1ord", "w1rd", "wo1d", "wor1", "2rd", "w2d", "wo2", "1o1d", "1or1", "w1r1", "1o2", "2r1", "3d", "w3", "4"]
+Hide Company Tags Google
+Show Tags
+Show Similar Problems
+

325_maximum_size_subarray/max.py

@@ -0,0 +1,19 @@
+from collections import defaultdict
+class Solution(object):
+    def maxSubArrayLen(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: int
+        """
+        sums = defaultdict(list)
+        sum = 0
+        result = 0
+        for i,num in enumerate(nums):
+            sums[sum].append(i)
+            sum += num
+            if sum-k in sums:
+                result = max(result,i+1-sums[sum-k][0])
+
+        return result
+        

325_maximum_size_subarray/problem.txt

@@ -0,0 +1,12 @@
+Given an array nums and a target value k, find the maximum length of a subarray that sums to k. If there isn't one, return 0 instead.
+
+Example 1:
+Given nums = [1, -1, 5, -2, 3], k = 3,
+return 4. (because the subarray [1, -1, 5, -2] sums to 3 and is the longest)
+
+Example 2:
+Given nums = [-2, -1, 2, 1], k = 1,
+return 2. (because the subarray [-1, 2] sums to 1 and is the longest)
+
+Follow Up:
+Can you do it in O(n) time?

333_largest_BST_subtree/largest.py

@@ -0,0 +1,44 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def largestBSTSubtree(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if not root: return 0
+        self.maxsize = 1
+        self.recurse(root)
+        return self.maxsize
+        
+    def recurse(self, node):
+        # return 3 things:
+        # 1. whether the subtree rooted at node is BST
+        # 2. the smallest value in the subtree
+        # 3. the largest value in the subtree
+        if not node.left and not node.right:
+            return (True, node.val, node.val, 1)
+            
+        is_BST = True
+        _min = node.val
+        _max = node.val
+        size = 1
+        if node.left:
+            (is_left_BST, leftmin, leftmax, leftsize) = self.recurse(node.left)
+            is_BST = is_BST and is_left_BST and node.val>leftmax
+            _min = min(_min, leftmin)
+            size += leftsize
+        if node.right:
+            (is_right_BST, rightmin, rightmax, rightsize) = self.recurse(node.right)
+            is_BST = is_BST and is_right_BST and node.val<rightmin
+            _max = max(_max, rightmax)
+            size += rightsize
+        if is_BST and size>self.maxsize:
+            self.maxsize = size
+        return is_BST, _min, _max, size
+        

333_largest_BST_subtree/problem.txt

@@ -0,0 +1,16 @@
+
+Given a binary tree, find the largest subtree which is a Binary Search Tree (BST), where largest means subtree with largest number of nodes in it.
+
+Note:
+A subtree must include all of its descendants.
+Here's an example:
+    10
+    / \
+   5  15
+  / \   \ 
+ 1   8   7
+The Largest BST Subtree in this case is the highlighted one. 
+The return value is the subtree's size, which is 3.
+Hint:
+
+You can recursively use algorithm similar to 98. Validate Binary Search Tree at each node of the tree, which will result in O(nlogn) time complexity.