add more solutions

Author: chihungyu1116

124 Binary Tree Maximum Path Sum.js

@@ -0,0 +1,34 @@
+// http://bangbingsyb.blogspot.com/2014/11/leetcode-binary-tree-maximum-path-sum.html
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxPathSum = function(root) {
+    var maxVal = -Infinity;
+    findMaxPath(root);
+    return maxVal;
+    
+    function findMaxPath(node) {
+        if(!node) {
+            return 0;
+        }
+        
+        var leftVal = Math.max(findMaxPath(node.left), 0);
+        var rightVal = Math.max(findMaxPath(node.right), 0);
+    
+        var ps1 = node.val + Math.max(leftVal, rightVal);
+        // ps2 means taking this current node as parent node and stop there
+        var ps2 = node.val + leftVal + rightVal;
+        
+        maxVal = Math.max(maxVal, Math.max(ps1, ps2));
+        // return ps1 only since, ps2 cannot be combined with the parent node
+        return ps1;
+    }
+};

139 Word Break.js

@@ -1,32 +1,28 @@
-// Leetcode #139
-// Language: Javascript
-// Problem: https://leetcode.com/problems/word-break/
-// Author: Chihung Yu
 /**
  * @param {string} s
  * @param {set<string>} wordDict
+ *   Note: wordDict is a Set object, see:
+ *   https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
  * @return {boolean}
  */
 var wordBreak = function(s, wordDict) {
-    if(wordDict === null || wordDict.size === 0){
+    if(wordDict === null || wordDict.size === 0) {
         return false;
     }
-    
-    var t = [];
-    t[0] = true;
 
-    for(var i = 0; i<s.length; i++){
-        if(t[i]){
-            for(var j = i+1; j <= s.length; j++){
-                var str = s.substring(i,j);
-                
-                if(wordDict.has(str)){
-                    t[j] = true;    
+    var possible = [];
+    possible[0] = true;
+    
+    for(var i = 0; i < s.length; i++) {
+        if(possible[i]) {
+            for(var j = i + 1; j <= s.length; j++) {
+                var str = s.substring(i, j);
+                if(wordDict.has(str)) {
+                    possible[j] = true;
                 }
-            }    
+            }
         }
     }
 
-    return t[s.length] === true;
-  
-}
+    return possible[s.length] === true;
+};

14 Longest Common Prefix.js

@@ -2,32 +2,29 @@
  * @param {string[]} strs
  * @return {string}
  */
-
 var longestCommonPrefix = function(strs) {
-    var result = "";
+    var len = strs.length;
+    var result = '';
 
-    if(strs === null || strs.length === 0){
+    if(len === 0) {
         return result;
     }
 
-    var minLen = Infinity;
-    
-    for(var i = 0; i < strs.length; i++){
-        if(strs[i].length < minLen){
-            minLen = strs[i].length;
-        }
-    }
-    var strIndex = 0;
-    var arrIndex = 1;
-    
-    
-    for(var x = 0; x < minLen; x++){
-        for(var y = 0; y < strs.length; y++){
-            if(strs[0][x] !== strs[y][x]){
-                return strs[0].substring(0,x);
+    for(var i = 0; i < strs[0].length; i++) {
+        var curChar = strs[0][i];
+        
+        for(var j = 1; j < len; j++) {
+            if(curChar !== strs[j][i]) {
+                return result;
+            }
+            
+            if(strs[j].length === i) {
+                return result;
             }
         }
+        
+        result += curChar;
     }
-  
-    return strs[0].substring(0, minLen);  
+    
+    return result;
 };

140 Word Break II.js

@@ -0,0 +1,53 @@
+// http://fisherlei.blogspot.com/2013/11/leetcode-wordbreak-ii-solution.html
+/**
+ * @param {string} s
+ * @param {set<string>} wordDict
+ *   Note: wordDict is a Set object, see:
+ *   https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Set
+ * @return {string[]}
+ */
+var wordBreak = function(s, wordDict) {
+    var result = [];
+    var solutions = [];
+    var len = s.length;
+    var possible = [];
+    
+    for(var i = 0; i <= s.length; i++) {
+        possible.push(true);
+    }
+    
+    getAllSolutions(0, s, wordDict, result, solutions, possible);
+    return solutions;
+};
+
+function getAllSolutions(start, s, wordDict, result, solutions, possible) {
+    if(start === s.length) {
+        solutions.push(result.join(' ')) // remove the last space
+        return;
+    }
+    
+    // loop through string from i to s.length
+    for(var i = start; i < s.length; i++) {
+        var piece = s.substring(start, i+1);
+        
+        // possible is to mark step whether i+1 to s.length have any possible words
+        if(wordDict.has(piece) && possible[i+1]) {// eliminate unnecessary search
+            result.push(piece);
+            var beforeChange = solutions.length;
+            getAllSolutions(i + 1, s, wordDict, result, solutions, possible);
+            if(solutions.length === beforeChange) {
+                possible[i+1] = false;
+            }
+            result.pop();
+        }
+    }
+}
+
+
+var dict = new Set();
+dict.add('leet');
+dict.add('code');
+dict.add('cod');
+dict.add('de');
+
+wordBreak('leetcode', dict)

144 Binary Tree Preorder Traversal My Submissions Question.js

@@ -14,21 +14,60 @@
  * @return {number[]}
  */
 
+// var preorderTraversal = function(root) {
+//     var result = [];
+    
+//     traverse(root, result);
+    
+//     return result;
+// };
+
+// function traverse(node, result) {
+//     if(!node) {
+//         return;
+//     }
+    
+//     result.push(node.val);
+    
+//     traverse(node.left, result);
+//     traverse(node.right, result);
+// }
+
+
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
 var preorderTraversal = function(root) {
     var result = [];
+
+    if(root === null) {
+        return result;
+    }
+    
+    var stack = [];
+    stack.push(root);
 
-    traverse(root, result);
+    while(stack.length) {
+        var node = stack.pop();
+        result.push(node.val);
+        
+        if(node.right !== null) {
+            stack.push(node.right);
+        }
+        if(node.left !== null) {
+            stack.push(node.left);
+        }
+    }
 
     return result;
 };
 
-function traverse(node, result) {
-    if(!node) {
-        return;
-    }
-    
-    result.push(node.val);
-    
-    traverse(node.left, result);
-    traverse(node.right, result);
-}

145 Binary Tree Post Order Traversal.js

@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+var postorderTraversal = function(root) {
+    var result = [];
+    var stack = [];
+    var prev = null;
+    var curr = null;
+    
+    if(root === null) {
+        return result;
+    }
+    
+    stack.push(root);
+    
+    // use prev and curr to figure out the direction of tree traversal
+    while(stack.length !== 0) {
+        curr = stack[stack.length - 1];
+        
+        if(prev === null || prev.left === curr || prev.right === curr) { // traverse down the tree
+            if(curr.left !== null) {
+                stack.push(curr.left);
+            } else if(curr.right !== null) {
+                stack.push(curr.right);
+            }
+        } else if(curr.left === prev) { //traverse up the tree from the left
+            if(curr.right !== null) {
+                stack.push(curr.right);
+            }
+        } else {
+            // it means that curr === prev 
+            result.push(curr.val);
+            stack.pop();
+        }
+        
+        prev = curr;
+    }
+    
+    return result;
+};

249 Group Shifted Strings.js

@@ -0,0 +1,45 @@
+// Given a string, we can "shift" each of its letter to its successive letter, for example: "abc" -> "bcd". We can keep "shifting" which forms the sequence:
+
+// "abc" -> "bcd" -> ... -> "xyz"
+// Given a list of strings which contains only lowercase alphabets, group all strings that belong to the same shifting sequence.
+
+// For example, given: ["abc", "bcd", "acef", "xyz", "az", "ba", "a", "z"], 
+// A solution is:
+
+// [
+//   ["abc","bcd","xyz"],
+//   ["az","ba"],
+//   ["acef"],
+//   ["a","z"]
+// ]
+// reference: http://blog.csdn.net/pointbreak1/article/details/48780345
+
+/**
+ * @param {string[]} strings
+ * @return {string[][]}
+ */
+var groupStrings = function(strings) {
+    var result = [];
+    var map = new Map();
+    
+    for(var i = 0; i < strings.length; i++) {
+        var shift = '';
+        var string = strings[i]
+        for(var j = 0; j < string.length; j++) {
+            shift += (string.charCodeAt(j) - string.charCodeAt(0) + 26)%26;
+            shift += ' ';
+        }
+        if(map.has(shift)) {
+            map.get(shift).push(string);
+        } else {
+            map.set(shift, [string]);
+        }
+    }
+
+    map.forEach((value, key)=> {
+        result.push(value);
+    });
+    
+    
+    return result;
+};