fixing conflicts

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;
+};

Hard/115-distinctSubsequences.js

@@ -0,0 +1,57 @@
+/**
+ * Solution: Dynamic programming
+ * match[i][j], the number of matched substrings when s with the length i and t with the length j.
+ * if s[i-1] !== s[j-1], then the matched number equals to the matched number of s with length i - 1.
+ * that is, match[i][j] = match[i-1][j].
+ * if s[i-1] == s[j-1], the matched number is the mathched number when s with length i - 1 and t with length j,
+ * plus the matched number when s with i - 1 length and t with j - 1 length.
+ *
+ * @param {string} s
+ * @param {string} t
+ * @return {number}
+ */
+var numDistinct = function(s, t) {
+    if (!s) return 0;
+
+    var match = [];
+    for (var i = 0; i <= s.length; i++) {
+        match[i] = [1];
+    }
+
+    for (var j = 1; j <= t.length; j++) {
+        match[0][j] = 0;
+    }
+
+    for (i = 1; i <= s.length; i++) {
+        for (j = 1; j <= t.length; j++) {
+            if (s[i - 1] === t[j - 1]) match[i][j] = match[i - 1][j - 1] + match[i - 1][j];
+            else match[i][j] = match[i - 1][j];
+        }
+    }
+
+    return match[s.length][t.length];
+
+};
+
+// just use one dimension array to store matched numbers
+var numDistinct = function(s, t) {
+    if (!s) return 0;
+    if (t.length > s.length) return 0;
+
+    var tLength = t.length;
+    var sLength = s.length;
+
+    var dp = [1];
+    for (var i = 1; i <= tLength; i++) {
+        dp.push(0);
+    }
+
+    for (i = 1; i <= sLength; i++) {
+        for (j = tLength; j >= 1; j--) {
+            if (s[i - 1] === t[j - 1]) dp[j] += dp[j - 1];
+        }
+    }
+
+    return dp[tLength];
+
+};

Hard/132-palindromePartitioningII.js

@@ -1,8 +1,7 @@
-/**
+/**
  * @param {string} s
  * @return {number}
  */
-
 var minCut = function(s) {
     if (!s) return 0;
     var length = s.length;
@@ -11,7 +10,7 @@ var minCut = function(s) {
         isPal[i] = [];
         for(var j = i; j < length; j++) {
             if ((j - i <= 2 || isPal[i+1][j-1]) && s[i] == s[j])
-              isPal[i][j] = true;
+                isPal[i][j] = true;
         }
     }
 

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/5-longestPalindromicSubstring.js

@@ -34,3 +34,29 @@ var getPalindromeSubstring = function(s, i, j) {
 
     return s.substring(i + 1, j);
 };
+
+
+// dp method, should work. memory exceed limit
+// bottom-up.
+var longestPalindrome = function(s) {
+    if (!s) return s;
+    var longest = s.substring(0, 1);
+    var length = s.length;
+    var dp = [];
+    var maxLength = 1;
+    for (var i = length - 1; i >= 0; i--) {
+        dp[i] = [];
+        for (var j = i; j < length; j++) {
+            // j - i <= 2 is important, in case i + 1 is out of array boundary.
+            if (s[i] === s[j] && (j - i <= 2 || dp[i + 1][j - 1])) {
+                dp[i][j] = true;
+                if (j - i + 1 > maxLength) {
+                    maxLength = j - i + 1;
+                    longest = s.substring(i, j + 1);
+                }
+            }
+        }
+    }
+
+    return longest;
+};

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];
+};