Add solution #975

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,058 LeetCode solutions in JavaScript
+# 1,059 LeetCode solutions in JavaScript
 
 [https://leetcode.com/](https://leetcode.com/)
 
@@ -783,6 +783,7 @@
 972|[Equal Rational Numbers](./solutions/0972-equal-rational-numbers.js)|Hard|
 973|[K Closest Points to Origin](./solutions/0973-k-closest-points-to-origin.js)|Medium|
 974|[Subarray Sums Divisible by K](./solutions/0974-subarray-sums-divisible-by-k.js)|Medium|
+975|[Odd Even Jump](./solutions/0975-odd-even-jump.js)|Hard|
 976|[Largest Perimeter Triangle](./solutions/0976-largest-perimeter-triangle.js)|Easy|
 977|[Squares of a Sorted Array](./solutions/0977-squares-of-a-sorted-array.js)|Easy|
 985|[Sum of Even Numbers After Queries](./solutions/0985-sum-of-even-numbers-after-queries.js)|Easy|

solutions/0975-odd-even-jump.js

@@ -0,0 +1,72 @@
+/**
+ * 975. Odd Even Jump
+ * https://leetcode.com/problems/odd-even-jump/
+ * Difficulty: Hard
+ *
+ * You are given an integer array arr. From some starting index, you can make a series of jumps.
+ * The (1st, 3rd, 5th, ...) jumps in the series are called odd-numbered jumps, and the (2nd,
+ * 4th, 6th, ...) jumps in the series are called even-numbered jumps. Note that the jumps are
+ * numbered, not the indices.
+ *
+ * You may jump forward from index i to index j (with i < j) in the following way:
+ * - During odd-numbered jumps (i.e., jumps 1, 3, 5, ...), you jump to the index j such that
+ *   arr[i] <= arr[j] and arr[j] is the smallest possible value. If there are multiple such
+ *   indices j, you can only jump to the smallest such index j.
+ * - During even-numbered jumps (i.e., jumps 2, 4, 6, ...), you jump to the index j such that
+ *   arr[i] >= arr[j] and arr[j] is the largest possible value. If there are multiple such
+ *   indices j, you can only jump to the smallest such index j.
+ * - It may be the case that for some index i, there are no legal jumps.
+ *
+ * A starting index is good if, starting from that index, you can reach the end of the array (index
+ * arr.length - 1) by jumping some number of times (possibly 0 or more than once).
+ *
+ * Return the number of good starting indices.
+ */
+
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+var oddEvenJumps = function(arr) {
+  const oddCanReach = new Array(arr.length).fill(false);
+  const evenCanReach = new Array(arr.length).fill(false);
+  oddCanReach[arr.length - 1] = true;
+  evenCanReach[arr.length - 1] = true;
+  let result = 1;
+
+  const sortedIndices = Array.from({ length: arr.length }, (_, i) => i);
+  sortedIndices.sort((a, b) => arr[a] - arr[b] || a - b);
+
+  const oddNext = new Array(arr.length);
+  const evenNext = new Array(arr.length);
+  const stack = [];
+
+  for (const i of sortedIndices) {
+    while (stack.length && stack[stack.length - 1] < i) {
+      oddNext[stack.pop()] = i;
+    }
+    stack.push(i);
+  }
+
+  sortedIndices.sort((a, b) => arr[b] - arr[a] || a - b);
+  stack.length = 0;
+
+  for (const i of sortedIndices) {
+    while (stack.length && stack[stack.length - 1] < i) {
+      evenNext[stack.pop()] = i;
+    }
+    stack.push(i);
+  }
+
+  for (let i = arr.length - 2; i >= 0; i--) {
+    if (oddNext[i] !== undefined) {
+      oddCanReach[i] = evenCanReach[oddNext[i]];
+      if (oddCanReach[i]) result++;
+    }
+    if (evenNext[i] !== undefined) {
+      evenCanReach[i] = oddCanReach[evenNext[i]];
+    }
+  }
+
+  return result;
+};