4 soulutions, 3 are dp.

Author: EasyHard

first-missing-positive.js

@@ -0,0 +1,40 @@
+var DEBUG = process.env.DEBUG;
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var firstMissingPositive = function(nums) {
+  // make the array 1-indexed. If you dont like this trick,
+  // the following loop needs to be more carefully,
+  nums.unshift(-1);
+  for (var i = 1; i < nums.length; i++) {
+    if (nums[i] !== i && nums[i] > 0 && nums[i] < nums.length) {
+      var to = nums[i];
+      while (to > 0 && to < nums.length && nums[to] !== to && to !== i) {
+        var tmp = nums[to];
+        nums[to] = to;
+        to = tmp;
+      }
+      if (to === i) nums[i] = to;
+    }
+  }
+  console.log(nums);
+  for (var i = 1; i < nums.length; i++)
+    if (nums[i] !== i) return i;
+  return nums.length;
+};
+
+function test(f) {
+
+  [
+    [[1, 2, 0]],
+    [[3,4,-1,1]],
+    [[1]],
+    [[1,2,3,5]],
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(firstMissingPositive);

jump-game-ii.in1.js

@@ -0,0 +1,37 @@
+var DEBUG = process.env.DEBUG;
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var jump = function(nums) {
+  var n = nums.length;
+  var f = [];
+  f[n-1] = 0;
+  for (var i = n - 2; i >= 0; i--) {
+    if (i + nums[i] >= n - 1) f[i] = 1;
+    else {
+      var ans = Number.MAX_SAFE_INTEGER;
+      for (var j = nums[i]; j >= 1; j--) {
+        ans = Math.min(ans, f[i+j] + 1);
+        if (ans === 2 || ans === f[i+1] && nums[i] < nums[i+1])
+          break;
+      }
+      f[i] = ans;
+    }
+  }
+  return f[0];
+};
+
+function test(f) {
+
+  [
+    [[5]],
+    [[2,3,1,1,4]],
+    require('./jump-game-ii.in1.js'),
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(jump);

jump-game-ii.js

@@ -0,0 +1,44 @@
+var DEBUG = process.env.DEBUG;
+
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+var largestRectangleArea = function(height) {
+  if (height.length === 0) return 0;
+  function recttol(height) {
+    var ans = [];
+    var stack = [];
+    height.forEach((h, idx) => {
+      while (stack.length && stack[stack.length - 1].h > h) {
+        var curr = stack.pop();
+        ans[curr.idx] = curr.h * (idx - curr.idx);
+      }
+      stack.push({h: h, idx: idx});
+    });
+    while (stack.length) {
+      var curr = stack.pop();
+      ans[curr.idx] = curr.h * (height.length - curr.idx);
+    }
+    return ans;
+  }
+  var l = recttol(height);
+  var r = recttol(height.reverse());
+  l.reverse();
+  var t = l.map((x, idx) => x + r[idx] - height[idx]);
+  return Math.max.apply(undefined, t);
+};
+
+function test(f) {
+
+  [
+    [[5]],
+    [[5,6, 5]],
+    [[5,4,5]],
+    [[2,1,5,6,2,3]],
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(largestRectangleArea);

largest-rectangle-in-histogram.js

@@ -0,0 +1,64 @@
+var DEBUG = process.env.DEBUG;
+
+var arrayMax = arr => Math.max.apply(undefined, arr);
+var deepCopy = matrix => matrix.map(row => row.slice(0));
+/**
+ * @param {character[][]} matrix
+ * @return {number}
+ */
+var maximalRectangle = function(matrix) {
+  var n = matrix.length;
+  if (n === 0) return 0;
+  var m = matrix[0].length;
+  var r = [];
+  matrix.forEach(row => {
+    var result = [];
+    for (var i = row.length - 1; i >= 0; i--) {
+      if (row[i] === '1') {
+        result.unshift((result[0] || 0) + 1);
+      } else {
+        result.unshift(0);
+      }
+    }
+    r.push(result);
+  });
+  // r is also f(i, j, 0);
+  var f = deepCopy(r);
+  var ans = arrayMax(r.map(arrayMax));
+  // updating f and ans.
+  for (var k = 1; k < matrix.length; k++) {
+    // for new k
+    for (var i = 0; i < n; i++) {
+      for (var j = 0; j < m; j++) {
+        if (i+k >= matrix.length) {
+          f[i][j] = 0;
+        } else {
+          f[i][j] = Math.min(r[i][j], f[i+1][j]);
+          ans = Math.max(ans, f[i][j]*(k+1));
+        }
+      }
+    }
+  }
+  return ans;
+};
+
+function test(f) {
+
+  [
+    [['1011',
+      '1101',
+      '1111',
+      '0110',
+     ]],
+    [['1111',
+      '1101',
+      '1111',
+      '1110',
+     ]],
+    [['1']],
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(maximalRectangle);