four solutions.

Author: EasyHard

best-time-to-buy-and-sell-stock-iii.js

@@ -0,0 +1,24 @@
+var DEBUG = process.env.DEBUG;
+
+var maxProfit = function(prices) {
+  var inf = Math.pow(2, 31);
+  var p = prices; p.push(-inf);
+  var np = p.length;
+  var f = [], b = [];
+  for (var i = 0; i <= np; i++) {
+    f.push(0);
+    b.push(0);
+  }
+  b[np] = -inf; b[np-1] = inf;
+  for (var t = 1; t <= 2; t++) {
+    // b for new k
+    for (var i = np - 2; i >= 0; i--) {
+      b[i] = Math.max(b[i+1], f[i+2]) + p[i+1] - p[i];
+    }
+    // f for new k
+    for (var i = np - 2; i >= 0; i--) {
+      f[i] = Math.max(b[i], f[i+1]);
+    }
+  }
+  return f[0];
+};

binary-tree-maximum-path-sum.js

@@ -0,0 +1,39 @@
+var DEBUG = process.env.DEBUG;
+var inf = Math.pow(2, 32);
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+function c(node) {
+  if (!node) return -inf;
+  if (node.c) return node.c;
+  return node.c = Math.max(c(node.left), c(node.right), 0) + node.val;
+}
+
+
+
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var maxPathSum = function(root) {
+  if (!root) return -inf;
+  var ans = Math.max(c(root), c(root.left) + c(root.right) + root.val);
+  return ans = Math.max(ans, maxPathSum(root.left), maxPathSum(root.right));
+};
+
+
+function test(f) {
+
+  [
+    [{val: 1, left: {val:2}, right: {val:3}}],
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(maxPathSum);

max-points-on-a-line.js

@@ -0,0 +1,80 @@
+var DEBUG = process.env.DEBUG;
+
+/*
+ * Definition for a point.
+ * function Point(x, y) {
+ *     this.x = x;
+ *     this.x = y;
+ * }
+ */
+
+/**
+ * @param {Point[]} points
+ * @return {number}
+ */
+var maxPoints = function(points) {
+  points = points.sort((p1, p2) => {
+    if (p1.x === p2.x) return p1.y - p2.y;
+    else return p1.x - p2.x;
+  });
+  var newpoints = [];
+  for (var i = 0; i < points.length; i++) {
+    if ( newpoints.length === 0 ||
+         points[i].x !== newpoints[newpoints.length - 1].x ||
+         points[i].y !== newpoints[newpoints.length - 1].y ) {
+      newpoints.push(points[i]);
+      newpoints[newpoints.length - 1].ndup = 1;
+    } else {
+      newpoints[newpoints.length - 1].ndup += 1;
+    }
+  }
+  points = newpoints;
+  if (points.length === 1) return points[0].ndup;
+  var inf = Math.pow(2, 48);
+  var max = 0;
+  for (i = 0; i < points.length; i++) {
+    var h = {};
+    for (var j = 0; j < points.length; j++) {
+      if (i === j) continue;
+      if (points[j].y >= points[i].y) {
+        var k, b;
+        if (points[j].x === points[i].x) {
+          k = inf;
+          b = points[i].x;
+        } else {
+          k = (points[j].y - points[i].y) / (points[j].x - points[i].x);
+          b = (points[i].x*points[j].y - points[j].x*points[i].y) / (points[i].x - points[j].x);
+        }
+        h[[k,b]] = h[[k,b]] || points[i].ndup;
+        h[[k,b]] += points[j].ndup;
+      }
+    }
+    var curr = 0;
+    for (var l in h) curr = Math.max(curr, h[l]);
+    max = Math.max(max, curr);
+  }
+  return max;
+};
+
+function buildp(p) {
+  return {
+    x:p[0], y:p[1]
+  };
+}
+
+
+function test(f) {
+
+  [
+    [[{x: 1, y:2}]],
+    [[{x: 1, y:2}, {x:1, y:2}]],
+    [[{x: 1, y:2}, {x:1, y:3}]],
+    [[{x: 1, y:2}, {x:1, y:3}, {x: 1, y: 4}, {x:2, y: 2}]],
+    [[{x:4,y:0},{x:4,y:-1},{x:4,y:5}]],
+    [[[-4,1],[-7,7],[-1,5],[9,-25]].map(buildp)],
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(maxPoints);

substring-with-concatenation-of-all-words.js

@@ -0,0 +1,58 @@
+var DEBUG = process.env.DEBUG;
+var M = 1572869;
+var M1 = 100663319;
+
+String.prototype.hash = function () {
+  var result = 0;
+  for (var i = 0; i < this.length; i++) {
+    result *= 26;
+    result += this.charCodeAt(i);
+    result %= M;
+  }
+  return result;
+};
+
+/**
+ * @param {string} s
+ * @param {string[]} words
+ * @return {number[]}
+ */
+var findSubstring = function(s, words) {
+  if (words.length === 0) return [];
+  var sl = s.length;
+  var wl = words[0].length;
+  var nw = words.length;
+
+  words.forEach(word => word.h = word.hash());
+  var T = 1;
+  for (var i = 0; i < s.length - 1; i++) T *= 26;
+  var h = s.substring(0, wl).hash();
+  var sh = [];
+  for (var i = wl; i < sl; i++) {
+    sh.push(h);
+    h = Math.floor((h / 26)) + s.charCodeAt(i) * T;
+  }
+
+  var wordsHashSum = 0;
+  words.forEach(word => wordsHashSum = (wordsHashSum + word.h) % M1);
+  var hashSum = [];
+  for (var t = 0; t < wl; t++) {
+    var currSum = 0;
+    if (t + (nw-1) * wl < sh.length) break;
+    for (var i = 0; i < nw; i++)
+      currSum = (currSum + sh[t + i*wl]) % M1;
+    i = t + nw * wl;
+    while (9 )
+  }
+};
+
+function test(f) {
+
+  [
+    [[]]
+  ].forEach(function (input) {
+    console.log(f.apply(undefined, input));
+  });
+}
+
+if (DEBUG) test(findSubstring);