Continue dynamic programming 91, 152, 120 Tree 106 String 151

Author: jyxia

Easy/104-maxDepth.js

@@ -22,3 +22,11 @@ var maxDepth = function(root) {
   }
   return max + 1;
 }
+
+// second try
+var maxDepth = function(root) {
+    if (!root) return 0;
+    var lHeight = maxDepth(root.left) + 1;
+    var rHeight = maxDepth(root.right) + 1;
+    return lHeight > rHeight ? lHeight : rHeight;
+};

Medium/106-constructBinaryTree.js

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number[]} inorder
+ * @param {number[]} postorder
+ * @return {TreeNode}
+ */
+var buildTree = function(inorder, postorder) {
+    return helper(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1);
+};
+
+var helper = function(inorder, inStart, inEnd, postorder, postStart, postEnd) {
+    if (inEnd < inStart || postEnd < postStart) return null;
+    var rootVal = postorder[postEnd];
+    var root = new TreeNode(rootVal);
+    for (var i = 0; i < inEnd; i++) {
+        if (inorder[i] === rootVal) {
+            break;
+        }
+    }
+    root.left = helper(inorder, inStart , i - 1 , postorder, postStart, postStart + i - 1 - inStart);
+    root.right = helper(inorder, i + 1, inEnd, postorder, postEnd - inEnd + i, postEnd - 1);
+    return root;
+};

Medium/114-flattenTree.js

@@ -13,3 +13,18 @@ var flatten = function(root) {
     while (oRoot.right) oRoot = oRoot.right;
     oRoot.right = oRight;
 };
+
+// 2nd try
+var flatten = function(root) {
+    if (!root) return;
+    // save right now
+    var tmp = root.right;
+    flatten(root.left);
+    flatten(root.right);
+    root.right = root.left;
+    root.left = null;
+    while (root.right) {
+        root = root.right;
+    }
+    root.right = tmp;
+};

Medium/120-triangle.js

@@ -0,0 +1,33 @@
+/**
+ * Dynamic programming
+ *
+ * @param {number[][]} triangle
+ * @return {number}
+ */
+// straightforward, top-down, space O(N^2)
+var minimumTotal = function(triangle) {
+    var dp = [triangle[0]];
+    for (var i = 1; i < triangle.length; i++) {
+        // in JavaScript, remember to have a new array for each row.
+        dp[i] = [];
+        for (var j = 0; j < triangle[i].length; j++) {
+            if (j === 0) dp[i][j] = dp[i - 1][j] + triangle[i][j];
+            else if (j === triangle[i].length - 1) dp[i][j] = dp[i - 1][j - 1] + triangle[i][j];
+            else dp[i][j] = Math.min(dp[i - 1][j - 1], dp[i - 1][j]) + triangle[i][j];
+        }
+    }
+    return Math.min.apply(null, dp[triangle.length - 1]);
+};
+
+// bottom-up, space O(N)
+var minimumTotal = function(triangle) {
+    var length = triangle.length;
+    var sum = triangle[length - 1];
+    for (var i = length - 2; i >= 0; i--) {
+        for (var j = 0; j < triangle[i].length; j++) {
+            sum[j] = Math.min(sum[j], sum[j + 1]) + triangle[i][j];
+        }
+        console.log(sum);
+    }
+    return sum[0];
+};

Medium/151-reverseWordsInAString.js

@@ -0,0 +1,16 @@
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+var reverseWords = function(str) {
+    var words = str.split(' ');
+    // the O(1) space
+    var j = 0;
+    for (var i = 0; i < words.length; i++) {
+        if (words[i] !== '') {
+            words[j] = words[i];
+            j++;
+        }
+    }
+    return words.slice(0, j).reverse().join(' ');
+};

Medium/152-MaxProductSubarray.js

@@ -0,0 +1,23 @@
+/**
+ * Solution: Two dp arrays: maxDP tracks the Maximum product at index i,
+ * minDP tracks the Minimum product at index i, either of them can be negative Numbers
+ * so if nums[i + 1] is negative, then maxDP[i+1] can be a product of minDP[i] * nums[i+1]
+ * @see the for loop body
+ *
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxProduct = function(nums) {
+    if (nums.length === 0) return 0;
+    var result = nums[0];
+    var maxDP = [nums[0]];
+    var minDP = [nums[0]];
+
+    for (var i = 1; i < nums.length; i++) {
+        maxDP[i] = Math.max(nums[i], maxDP[i - 1] * nums[i], minDP[i - 1] * nums[i]);
+        minDP[i] = Math.min(nums[i], minDP[i - 1] * nums[i], maxDP[i - 1] * nums[i]);
+        result = Math.max(maxDP[i], result);
+    }
+
+    return result;
+};

Medium/91-decodeways.js

@@ -0,0 +1,22 @@
+/**
+ * solution: dp[i] = dp[i - 1] if s[i - 1] is valid (!= 0)
+ * or dp[i] = dp[i-2] if s[i-1] is not valid, however s.substring(i-2, i) is valid ( >=10 && <=26)
+ * or dp[i] = dp[i-1] + dp[i-2] is both s.substring(i-2, i), s.substring(i-1, i) are valid
+ *
+ * @param {string} s
+ * @return {number}
+ */
+var numDecodings = function(s) {
+    if (s.length === 0) return 0;
+    var dp = [1];
+    s[0] === '0' ? dp[1] = 0 : dp[1] = 1;
+
+    for (var i = 2; i <= s.length; i++) {
+        var prevTwo = parseInt(s.substring(i - 2, i));
+        dp[i] = 0;
+        if (s[i - 1] !== '0') dp[i] = dp[i - 1];
+        if (prevTwo >= 10 && prevTwo <= 26 ) dp[i] += dp[i - 2];
+    }
+
+    return dp[s.length];
+};

README.md

@@ -112,25 +112,30 @@
 * [86. Partition List](https://leetcode.com/problems/partition-list/) - [Solution](./Medium/86-partition-List.js)
 * [89. Gray Code](https://leetcode.com/problems/gray-code/) - [Solution](./Medium/89-grayCode.js)
 * [90. Subsets II ](https://leetcode.com/problems/subsets-ii/) - [Solution](./Medium/90-subsetsII.js)
+* [91. Decode Ways ](https://leetcode.com/problems/decode-ways/) - [Solution](./Medium/91-decodeways.js)
 * [92. Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii/) - [Solution](./Medium/92-reverseLinkedListII.js)
 * [93. Restore IP Addresses](https://leetcode.com/problems/restore-ip-addresses/) - [Solution](./Medium/93-restoreIPAddresses.js)
 * [94. Binary Tree Inorder Traversal](https://leetcode.com/problems/binary-tree-inorder-traversal/) - [Solution](./Medium/94-binaryTreeInorder.js)
 * [96. Unique Binary Search Trees](https://leetcode.com/problems/unique-binary-search-trees/) - [Solution](./Medium/96-uniqueBinarySearchTrees.js)
 * [98. Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/) - [Solution](./Medium/98-validateBST.js)
 * [103. Binary Tree Zigzag Level Order Traversal](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/) - [Solution](./Medium/103-BSTZigzagLevelTraversal.js)
 * [105. Construct Binary Tree from Preorder and Inorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/) - [Solution](./Medium/105-constructBinaryTree.js)
+* [106. Construct Binary Tree from Inorder and Postorder Traversal](https://leetcode.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/) - [Solution](./Medium/106-constructBinaryTree.js)
 * [108. Convert Sorted Array to Binary Search Tree](https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/) - [Solution](./Medium/108-convertSortedArraytoBST.js)
 * [109. Convert Sorted List to Binary Search Tree](https://leetcode.com/problems/convert-sorted-list-to-binary-search-tree/) - [Solution](./Medium/109-convertSortedListToBST.js)
 * [113. Path Sum II](https://leetcode.com/problems/path-sum-ii/) - [Solution](./Medium/113-pathSumII.js)
 * [114. Flatten Binary Tree to Linked List](https://leetcode.com/problems/flatten-binary-tree-to-linked-list/) - [Solution](./Medium/114-flattenTree.js)
 * [116. Populating Next Right Pointers in Each Node](https://leetcode.com/problems/populating-next-right-pointers-in-each-node/) - [Solution](./Medium/116-PopulatingNextRightPointersinEachNode.js)
+* [120. Triangle](https://leetcode.com/problems/triangle/) - [Solution](./Medium/120-triangle.js)
 * [121. Best Time to Buy and Sell Stock](https://leetcode.com/problems/best-time-to-buy-and-sell-stock/) - [Solution](./Medium/121-bestTimeToBuySellStock.js)
 * [122. Best Time to Buy and Sell Stock II](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/) - [Solution](./Medium/122-bestTimeToBuySellStockII.js)
 * [129. Sum Root to Leaf Numbers](https://leetcode.com/problems/sum-root-to-leaf-numbers/) - [Solution](./Medium/129-sumRootToLeafNumbers.js)
 * [134. Gas Station](https://leetcode.com/problems/gas-station/) - [Solution](./Medium/134-gasStation.js)
 * [136. Single Number](https://leetcode.com/problems/single-number/) - [Solution](./Medium/136-singleNumber.js)
 * [141. Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/) - [Solution](./Medium/141-linkedListCycle.js)
 * [144. Binary Tree Preorder Traversal](https://leetcode.com/problems/binary-tree-preorder-traversal/) - [Solution](./Medium/144-binaryTreePreorder.js)
+* [151. Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/) - [Solution](./Medium/151-reverseWordsInAString.js)
+* [152. Maximum Product Subarray](https://leetcode.com/problems/maximum-product-subarray/) - [Solution](./Medium/152-MaxProductSubarray.js)
 * [153.	Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/) - [Solution](./Medium/153-findMinimumInRotatedSortedArray.js)
 * [162. Find Peak Element](https://leetcode.com/problems/find-peak-element/) - [Solution](./Medium/162-findPeakElement.js)
 * [199. Binary Tree Right Side View](https://leetcode.com/problems/binary-tree-right-side-view/) - [Solution](./Medium/199-binaryTreeRightSideView.js)