more solutions

Author: Chihung Yu

108 Convert Sorted Array to Binary Search Tree.js

@@ -25,11 +25,9 @@ var generate = function(nums, start, end){
     var midIndex = start + parseInt((end - start)/2);
     var midVal = nums[midIndex];
 
-    var left = generate(nums, start, midIndex-1);
     var node = new TreeNode(midVal);
-    node.left = left;
-    var right = generate(nums, midIndex+1, end);
-    node.right = right;
+    node.left = generate(nums, start, midIndex-1);
+    node.right = generate(nums, midIndex+1, end);
 
     return node;
 }

12 Integer to Roman.js

@@ -0,0 +1,28 @@
+// Leetcode 12
+// Language: Javascript
+// Problem: https://leetcode.com/problems/integer-to-roman/
+// Author: Chihung Yu
+/**
+ * @param {number} num
+ * @return {string}
+ */
+var intToRoman = function(num) {
+    var dict = ["M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"];
+    var val = [1000,900,500,400,100,90,50,40,10,9,5,4,1];
+    var result = "";
+    
+    for(var i = 0; i < val.length; i++) {
+        var v = val[i];
+        
+        if(num >= v) {
+            var count = parseInt(num/v);
+            num %= v;
+            
+            for(var j = 0; j < count; j++) {
+                result = result + dict[i];
+            }
+        }
+    }
+    
+    return result;
+};

173 Binary Search Tree Iterator.js

@@ -0,0 +1,54 @@
+/**
+ * Definition for binary tree
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+/**
+ * @constructor
+ * @param {TreeNode} root - root of the binary search tree
+ */
+var BSTIterator = function(root) {
+    this.stack = [];
+    this.pushLeft(root);
+};
+
+
+/**
+ * @this BSTIterator
+ * @returns {boolean} - whether we have a next smallest number
+ */
+BSTIterator.prototype.hasNext = function() {
+    return this.stack.length !== 0;
+};
+
+/**
+ * @this BSTIterator
+ * @returns {number} - the next smallest number
+ */
+BSTIterator.prototype.next = function() {
+    if(this.hasNext()) {
+        var node = this.stack.pop();
+        
+        if(node.right) {
+            this.pushLeft(node.right);
+        }
+        
+        return node.val;
+    }
+};
+
+BSTIterator.prototype.pushLeft = function(node) {
+    while(node) {
+        this.stack.push(node);
+        node = node.left;
+    }
+}
+
+/**
+ * Your BSTIterator will be called like this:
+ * var i = new BSTIterator(root), a = [];
+ * while (i.hasNext()) a.push(i.next());
+*/

240 Search a 2D Matrix II.js

@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} matrix
+ * @param {number} target
+ * @return {boolean}
+ */
+var searchMatrix = function(matrix, target) {
+    var row = matrix.length;
+    
+    if(row === 0) {
+        return false;
+    }
+    
+    var col = matrix[0].length;
+    
+    if(col === 0) {
+        return false;
+    }
+    
+    var j = col - 1;
+    for(var i = 0; i < row; i++) {
+        while(j && matrix[i][j] > target) {
+            j--;
+        }
+        if(matrix[i][j] === target) {
+            return true;
+        }
+    }
+    return false;
+};

241 Different Ways to Add Parentheses.js

@@ -1,3 +1,7 @@
+// Leetcode 35
+// Language: Javascript
+// Problem: https://leetcode.com/problems/search-insert-position/
+// Author: Chihung Yu
 /**
  * @param {number[]} nums
  * @param {number} target

35 Search Insert Position.js

@@ -0,0 +1,33 @@
+// Leetcode 309
+// Language: Javascript
+// Problem: https://leetcode.com/problems/permutations/
+// Author: Chihung Yu
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+var permute = function(nums) {
+    var result = [];
+    var visited = [];
+    
+    generate(nums, 0, visited, [], result);
+    
+    return result;
+};
+
+var generate = function(nums, index, visited, output, result) {
+    if(nums.length === output.length) {
+        result.push(output.slice());
+    }
+    
+    for(var i = 0; i < nums.length; i++) {
+        if(!visited[i]) {
+            visited[i] = true;
+            output.push(nums[i]);
+            generate(nums, index+1, visited, output, result);    
+            output.pop();
+            visited[i] = false;
+        }
+        
+    }
+}

46 Permutations.js

@@ -2,32 +2,72 @@
  * @param {number[][]} grid
  * @return {number}
  */
-var minPathSum = function(grid) {
-    if(grid === null || grid.length === 0 || grid[0].length === 0){
-        return 0;
-    }
+// var minPathSum = function(grid) {
+//     if(grid === null || grid.length === 0 || grid[0].length === 0){
+//         return 0;
+//     }
 
-    var dp = [[]];
+//     var dp = [[]];
 
-    dp[0][0] = grid[0][0];
+//     dp[0][0] = grid[0][0];
 
-    for(var i = 1; i < grid.length; i++){
-        dp.push([]);
-        dp[i][0] = grid[i][0] + dp[i - 1][0];
-    }
+//     for(var i = 1; i < grid.length; i++){
+//         dp.push([]);
+//         dp[i][0] = grid[i][0] + dp[i - 1][0];
+//     }
+    
+//     for(var j = 1; j < grid[0].length; j++){
+//         dp[0][j] = grid[0][j] + dp[0][j - 1];
+//     }
+    
+//     for(i = 1; i < grid.length; i++){
+//         for(j = 1; j < grid[i].length; j++){
+//             var val1 = dp[i - 1][j];
+//             var val2 = dp[i][j - 1];
+            
+//             dp[i][j] = Math.min(val1, val2) + grid[i][j];
+//         }
+//     }
+    
+//     return dp[dp.length - 1][dp[0].length - 1];
+// }
+
+
+/**
+ * @param {number[][]} triangle
+ * @return {number}
+ */
+
+ // use only O(n) space
+var minimumTotal = function(triangle) {
+    var preResult = [];
+    var rows = triangle.length;
 
-    for(var j = 1; j < grid[0].length; j++){
-        dp[0][j] = grid[0][j] + dp[0][j - 1];
+    if(rows > 0) {
+        preResult.push(triangle[0][0]);
+    } else {
+        return null;
     }
 
-    for(i = 1; i < grid.length; i++){
-        for(j = 1; j < grid[i].length; j++){
-            var val1 = dp[i - 1][j];
-            var val2 = dp[i][j - 1];
+    for(var row = 1; row < rows; row++) {
+        var curResult = [];
+        
+        for(var col = 0; col < triangle[row].length; col++) {
+            var val;
 
-            dp[i][j] = Math.min(val1, val2) + grid[i][j];
+            if(col === 0) {
+                val = preResult[col];
+            } else if(col === (triangle[row].length - 1)) {
+                val = preResult[col-1];
+            } else {
+                val = Math.min(preResult[col-1], preResult[col]);
+            }
+        
+            curResult[col] = triangle[row][col] + val;
         }
+        
+        preResult = curResult;
     }
 
-    return dp[dp.length - 1][dp[0].length - 1];
-}
+    return Math.min.apply(null, preResult);
+};

64 Minimum Path Sum.js

@@ -4,19 +4,22 @@
  */
 var removeDuplicates = function(nums) {
     var n = nums.length;
+    var index = 0;
+    var oc = 1;
 
-    for(var i = 0; i < n; i++){
-        var cur = nums[i];
-        if(cur === nums[i + 1]){
-            var isDup = true;
-            var next = i + 2;
-            
-            while(next < n && cur === nums[next]){
-                nums.splice(next, 1);
-                n--;
+    for(var i = 1; i < nums.length; i++) {
+        if(nums[index] === nums[i]) {
+            if(oc === 2) {
+                continue;
             }
+            oc++;
+        } else {
+            oc = 1;
         }
+        
+        index++;
+        nums[index] = nums[i];
     }
 
-    return n;
+    return index + 1;
 };

80 Remove Duplicates from Sorted Array II.js

@@ -123,4 +123,5 @@ By Chihung Yu
 93 Restore IP Addresses.<br />
 94 Binary Tree Inorder Traversal<br />
 98 Validate Binary Search Tree<br />
+318 Maximum Product of Word Lengths <br />
 README.md