Add solution #2407

Author: JoshCrozier

README.md

@@ -2183,6 +2183,7 @@
 2404|[Most Frequent Even Element](./solutions/2404-most-frequent-even-element.js)|Easy|
 2405|[Optimal Partition of String](./solutions/2405-optimal-partition-of-string.js)|Medium|
 2406|[Divide Intervals Into Minimum Number of Groups](./solutions/2406-divide-intervals-into-minimum-number-of-groups.js)|Medium|
+2407|[Longest Increasing Subsequence II](./solutions/2407-longest-increasing-subsequence-ii.js)|Hard|
 2408|[Design SQL](./solutions/2408-design-sql.js)|Medium|
 2409|[Count Days Spent Together](./solutions/2409-count-days-spent-together.js)|Easy|
 2410|[Maximum Matching of Players With Trainers](./solutions/2410-maximum-matching-of-players-with-trainers.js)|Medium|

solutions/2407-longest-increasing-subsequence-ii.js

@@ -0,0 +1,65 @@
+/**
+ * 2407. Longest Increasing Subsequence II
+ * https://leetcode.com/problems/longest-increasing-subsequence-ii/
+ * Difficulty: Hard
+ *
+ * You are given an integer array nums and an integer k.
+ *
+ * Find the longest subsequence of nums that meets the following requirements:
+ * - The subsequence is strictly increasing and
+ * - The difference between adjacent elements in the subsequence is at most k.
+ *
+ * Return the length of the longest subsequence that meets the requirements.
+ *
+ * A subsequence is an array that can be derived from another array by deleting some or
+ * no elements without changing the order of the remaining elements.
+ */
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var lengthOfLIS = function(nums, k) {
+  const maxValue = Math.max(...nums);
+  const tree = new Array(4 * maxValue).fill(0);
+
+  for (const currentNum of nums) {
+    const rangeStart = Math.max(1, currentNum - k);
+    const rangeEnd = currentNum - 1;
+
+    const bestPreviousLength = rangeEnd >= rangeStart
+      ? queryRange(1, 1, maxValue, rangeStart, rangeEnd) : 0;
+    updatePosition(1, 1, maxValue, currentNum, bestPreviousLength + 1);
+  }
+
+  return queryRange(1, 1, maxValue, 1, maxValue);
+
+  function updatePosition(nodeIndex, treeStart, treeEnd, position, newLength) {
+    if (treeStart === treeEnd) {
+      tree[nodeIndex] = Math.max(tree[nodeIndex], newLength);
+    } else {
+      const treeMid = Math.floor((treeStart + treeEnd) / 2);
+      if (position <= treeMid) {
+        updatePosition(2 * nodeIndex, treeStart, treeMid, position, newLength);
+      } else {
+        updatePosition(2 * nodeIndex + 1, treeMid + 1, treeEnd, position, newLength);
+      }
+      tree[nodeIndex] = Math.max(tree[2 * nodeIndex], tree[2 * nodeIndex + 1]);
+    }
+  }
+
+  function queryRange(nodeIndex, treeStart, treeEnd, queryStart, queryEnd) {
+    if (queryEnd < treeStart || treeEnd < queryStart) {
+      return 0;
+    }
+    if (queryStart <= treeStart && treeEnd <= queryEnd) {
+      return tree[nodeIndex];
+    }
+    const mid = Math.floor((treeStart + treeEnd) / 2);
+    return Math.max(
+      queryRange(2 * nodeIndex, treeStart, mid, queryStart, queryEnd),
+      queryRange(2 * nodeIndex + 1, mid + 1, treeEnd, queryStart, queryEnd)
+    );
+  }
+};