Add solution #1340

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,241 LeetCode solutions in JavaScript
+# 1,242 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -1017,6 +1017,7 @@
 1337|[The K Weakest Rows in a Matrix](./solutions/1337-the-k-weakest-rows-in-a-matrix.js)|Easy|
 1338|[Reduce Array Size to The Half](./solutions/1338-reduce-array-size-to-the-half.js)|Medium|
 1339|[Maximum Product of Splitted Binary Tree](./solutions/1339-maximum-product-of-splitted-binary-tree.js)|Medium|
+1340|[Jump Game V](./solutions/1340-jump-game-v.js)|Hard|
 1342|[Number of Steps to Reduce a Number to Zero](./solutions/1342-number-of-steps-to-reduce-a-number-to-zero.js)|Easy|
 1351|[Count Negative Numbers in a Sorted Matrix](./solutions/1351-count-negative-numbers-in-a-sorted-matrix.js)|Easy|
 1352|[Product of the Last K Numbers](./solutions/1352-product-of-the-last-k-numbers.js)|Medium|

solutions/1340-jump-game-v.js

@@ -0,0 +1,61 @@
+/**
+ * 1340. Jump Game V
+ * https://leetcode.com/problems/jump-game-v/
+ * Difficulty: Hard
+ *
+ * Given an array of integers arr and an integer d. In one step you can jump from index i to index:
+ * - i + x where: i + x < arr.length and  0 < x <= d.
+ * - i - x where: i - x >= 0 and  0 < x <= d.
+ *
+ * In addition, you can only jump from index i to index j if arr[i] > arr[j] and arr[i] > arr[k] for
+ * all indices k between i and j (More formally min(i, j) < k < max(i, j)).
+ *
+ * You can choose any index of the array and start jumping. Return the maximum number of indices you
+ * can visit.
+ *
+ * Notice that you can not jump outside of the array at any time.
+ */
+
+/**
+ * @param {number[]} arr
+ * @param {number} d
+ * @return {number}
+ */
+var maxJumps = function(arr, d) {
+  const n = arr.length;
+  const memo = new Array(n).fill(0);
+  let result = 1;
+
+  for (let i = 0; i < n; i++) {
+    result = Math.max(result, exploreJumps(i));
+  }
+
+  return result;
+
+  function exploreJumps(index) {
+    if (memo[index]) return memo[index];
+
+    let maxJumpsFromHere = 1;
+
+    for (let offset = 1; offset <= d; offset++) {
+      const right = index + offset;
+      if (right < n && arr[index] > arr[right]) {
+        maxJumpsFromHere = Math.max(maxJumpsFromHere, 1 + exploreJumps(right));
+      } else {
+        break;
+      }
+    }
+
+    for (let offset = 1; offset <= d; offset++) {
+      const left = index - offset;
+      if (left >= 0 && arr[index] > arr[left]) {
+        maxJumpsFromHere = Math.max(maxJumpsFromHere, 1 + exploreJumps(left));
+      } else {
+        break;
+      }
+    }
+
+    memo[index] = maxJumpsFromHere;
+    return maxJumpsFromHere;
+  }
+};