add DP questoins

Author: dingjy94

algorithm/DP/subsequence/countingBits.js

@@ -0,0 +1,25 @@
+/**
+ * lc338 counting bits (https://leetcode.com/problems/counting-bits/)
+ * Given a non negative integer number num.
+ * For every numbers i in the range 0 ≤ i ≤ num calculate the number of 1's in their binary representation
+ * and return them as an array.
+ * @param {number} num
+ * @return {number[]}
+ */
+var countBits = function (num) {
+  const result = [];
+  result[0] = 0;
+  let j = 1;
+  // prefix, DP(x + b) = DP(x) + 1, b = 2^m > x
+  while (j <= num) {
+    let i = 0;
+    while (i < j && i + j <= num) {
+      result[i + j] = result[i] + 1;
+      i += 1;
+    }
+
+    j *= 2;
+  }
+
+  return result;
+};

algorithm/DP/subsequence/longestIncreaseSubsequence.js

@@ -0,0 +1,27 @@
+/**
+ * Given an unsorted array of integers, find the length of longest increasing subsequence.
+ * lc300(https://leetcode.com/problems/longest-increasing-subsequence/)
+ * Input: [10,9,2,5,3,7,101,18]
+ * Output: 4
+ * @param {number[]} nums
+ * @return {number}
+ */
+var lengthOfLIS = function (nums) {
+  let sub = [];
+  let result = 0;
+
+  for (let num of nums) {
+    let i = 0, j = result;
+    while (i !== j) {
+      const mid = Math.floor((i + j) / 2);
+      if (sub[mid] < num) {
+        i = mid + 1;
+      } else {
+        j = mid;
+      }
+    }
+    sub[i] = num;
+    if (i === result) result++;
+  }
+  return result
+};

algorithm/DP/subsequence/stoneGamesII.js

@@ -0,0 +1,44 @@
+// lc1140 stone games II (https://leetcode.com/problems/stone-game-ii/)
+// Alex and Lee continue their games with piles of stones.There are a number of piles arranged in a row, and each pile has a positive integer number of stones piles[i].The objective of the game is to end with the most stones.
+// Alex and Lee take turns, with Alex starting first.Initially, M = 1.
+// On each player's turn, that player can take all the stones in the first X remaining piles, where 1 <= X <= 2M.  Then, we set M = max(M, X).
+// The game continues until all the stones have been taken.
+// Assuming Alex and Lee play optimally, return the maximum number of stones Alex can get.
+
+/**
+ * Basic idea: suffix, store M
+ * @param {number[]} piles
+ * @return {number}
+ */
+const dp = (piles, i, M, memo) => {
+
+  if (memo[i] === undefined) {
+    memo[i] = new Map();
+  }
+
+  if (memo[i].has(M)) {
+    return memo[i].get(M);
+  }
+
+  let sum = 0;
+  for (let n = i; n < piles.length; n++) {
+    sum += piles[n];
+  }
+
+  if (piles.length - i <= 2 * M) {
+    return sum;
+  }
+
+  let min = Number.MAX_VALUE;
+  for (let x = 1; x <= 2 * M; x++) {
+    min = Math.min(min, dp(piles, i + x, Math.max(x, M), memo));
+  }
+
+  memo[i].set(M, sum - min);
+
+  return sum - min;
+};
+
+var stoneGameII = function (piles) {
+  return dp(piles, 0, 1, []);
+};