给定一个整数数组 A，你可以从某一起始索引出发，跳跃一定次数。在你跳跃的过程中，第 1、3、5... 次跳跃称为奇数跳跃，而第 2、4、6... 次跳跃称为偶数跳跃。
你可以按以下方式从索引 i 向后跳转到索引 j（其中 i < j）：
- 在进行奇数跳跃时（如，第 1，3，5... 次跳跃），你将会跳到索引
j，使得A[i] <= A[j]，A[j]是可能的最小值。如果存在多个这样的索引j，你只能跳到满足要求的最小索引j上。 - 在进行偶数跳跃时（如，第 2，4，6... 次跳跃），你将会跳到索引
j，使得A[i] >= A[j]``A[j]是可能的最大值。如果存在多个这样的索引j，你只能跳到满足要求的最小索引j上。 - （对于某些索引
i，可能无法进行合乎要求的跳跃。）
如果从某一索引开始跳跃一定次数（可能是 0 次或多次），就可以到达数组的末尾（索引 A.length - 1），那么该索引就会被认为是好的起始索引。
返回好的起始索引的数量。
示例 1：
输入： [10,13,12,14,15]
输出： 2
解释：
从起始索引 i = 0 出发，我们可以跳到 i = 2，（因为 A[2] 是 A[1]，A[2]，A[3]，A[4]
中大于或等于 A[0] 的最小值），然后我们就无法继续跳下去了。
从起始索引 i = 1 和 i = 2 出发，我们可以跳到 i = 3，然后我们就无法继续跳下去了。
从起始索引 i = 3 出发，我们可以跳到 i = 4，到达数组末尾。
从起始索引 i = 4 出发，我们已经到达数组末尾。
总之，我们可以从 2 个不同的起始索引（i = 3, i = 4）出发，通过一定数量的跳跃到达数组末尾。
示例 2：
输入： [2,3,1,1,4]
输出： 3
解释：
从起始索引 i=0 出发，我们依次可以跳到 i = 1，i = 2，i = 3：
在我们的第一次跳跃（奇数）中，我们先跳到 i = 1，因为 A[1] 是（A[1]，A[2]，A[3]，A[4]）
中大于或等于 A[0] 的最小值。
在我们的第二次跳跃（偶数）中，我们从 i = 1 跳到 i = 2，因为 A[2] 是（A[2]，A[3]，A[4]）
中小于或等于 A[1] 的最大值。A[3] 也是最大的值，但 2 是一个较小的索引，所以我们只能跳到 i = 2，
而不能跳到 i = 3。
在我们的第三次跳跃（奇数）中，我们从 i = 2 跳到 i = 3，因为 A[3] 是（A[3]，A[4]）
中大于或等于 A[2] 的最小值。
我们不能从 i = 3 跳到 i = 4，所以起始索引 i = 0 不是好的起始索引。
类似地，我们可以推断：
从起始索引 i = 1 出发， 我们跳到 i = 4，这样我们就到达数组末尾。
从起始索引 i = 2 出发， 我们跳到 i = 3，然后我们就不能再跳了。
从起始索引 i = 3 出发， 我们跳到 i = 4，这样我们就到达数组末尾。
从起始索引 i = 4 出发，我们已经到达数组末尾。
总之，我们可以从 3 个不同的起始索引（i = 1, i = 3, i = 4）出发，
通过一定数量的跳跃到达数组末尾。
示例 3：
输入： [5,1,3,4,2]
输出： 3
解释：
我们可以从起始索引 1，2，4 出发到达数组末尾。
解题思路
思路：排序预处理，单调栈，动态规划， 首先分两种情况进行处理，奇数次跳跃和偶数次跳跃。
- 我们使用
odd数组来记录奇数次跳跃的下一个下标，即：odd[i]表示此次跳跃为奇数次跳跃，并且从下标i跳跃至下标odd[i]。 - 我们使用
even数组来记录偶数次跳跃的下一个下标，即：even[i]表示此次跳跃为偶数次跳跃，并且从下标i跳跃至下标even[i]。 - 然后使用
res数组来记录跳跃到当前位置的方案数，即：res[i]表示可以由前面多少个下标跳跃到下标i。
接下来就是求 odd、even、res 数组。
对于 odd 数组和 even 数组，可以使用单调栈来求解。
首先对原数组进行排序（当然也可以不改变原数组，而是使用一个 order 数组记录排序之后的下标，即：arr[order[i]] 是有序的数组）。
- 如果是求 odd 数组，按照从小到大的顺序排序，如果两个元素相等，则按照下标从小到大排序；
- 如果是求 even 数组，按照从大到小的顺序排序，如果两个元素相等，也按照下标从小到大排序。
排序的好处是：直接往后找下一次跳跃的位置，
如果是：
-
奇数次跳跃，则可以直接往后找大于当前下标的第一个下标，因为数组元素是从小到大排列，我们要找的就是：大于等于当前元素、在当前元素之后、且尽可能小、距离当前元素尽可能近的元素。
-
偶数次跳跃，则可以直接往后找小于当前下标的第一个下标，因为数组元素是从大到小排列，我们要找的就是：小于等于当前元素、在当前元素之后、且尽可能大、距离当前元素尽可能近的元素。
这个可以使用单调栈来求，栈中存放下标，维护一个单调递减的栈。
利用单调栈找到后面第一个大于栈顶下标的下标，求出 odd 和 even 数组。
求出 odd 和 even 数组之后，就可以用动态规划求 res 数组了。
res 数组为二维数组，对于 res[i][j]，i 表示下一跳的位置，j 取值 0 或 1，分别代表下一次跳跃是偶数次跳跃还是奇数次跳跃。
假设 odd[i] 表示此次跳跃为奇数次跳跃，从下标 i 跳跃至下标 odd[i]，则 res[i][0] 表示第偶数次跳跃至下标 i 的方案数，res[odd[i]][1] 表示第奇数次跳跃至下标 odd[i] 的方案数，
状态转移方程为（从第偶数次跳跃至第奇数次跳跃转移）：
res[odd[i]][1] += res[i][0]
假设 even[i] 表示此次跳跃为偶数次跳跃，从下标 i 跳跃至下标 even[i]，
则 res[i][1] 表示第奇数次跳跃至下标 i 的方案数，res[even[i]][0] 表示第偶数次跳跃至下标 even[i] 的方案数，
状态转移方程为（从第奇数次跳跃至第偶数次跳跃转移）：
res[even[i]][0] += res[i][1]
在初始化的时候，我们初始化 res[i][0] = 1，可以看成是 0 次（偶数次）跳跃到达下标 i。
最后 res[n-1][0] + res[n-1][1] 即为要求的值。
作者：20182726
链接：leetcode.cn/problems/od… 来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
题解：
/**
* @param {number[]} arr
* @return {number}
*/
var oddEvenJumps = function(arr) {
const n = arr.length;
const order = new Array(n).fill(0).map((_, i) => i);
const stack = [];
const odd = [];
const even = [];
const res = new Array(n).fill(0).map(() => [1, 0]);
order.sort((i, j) => {
if(arr[i] !== arr[j]) {
return arr[i] - arr[j];
}
return i - j;
});
for(let i = 0; i < n; i++) {
while(stack.length && stack[stack.length-1] < order[i]) {
const top = stack.pop();
odd[top] = order[i];
}
stack.push(order[i]);
}
while(stack.length) {
const top = stack.pop();
odd[top] = -1;
}
order.sort((i, j) => {
if(arr[i] !== arr[j]) {
return arr[j] - arr[i];
}
return i - j;
});
for(let i = 0; i < n; i++) {
while(stack.length && stack[stack.length-1] < order[i]) {
const top = stack.pop();
even[top] = order[i];
}
stack.push(order[i]);
}
while(stack.length) {
const top = stack.pop();
even[top] = -1;
}
for(let i = 0; i < n; i++) {
if(odd[i] !== -1) {
res[odd[i]][1] += res[i][0];
}
if(even[i] !== -1) {
res[even[i]][0] += res[i][1];
}
}
// console.log('odd:', odd);
// console.log('even:', even);
// console.log('res:', res);
// console.log(res[n-1][0] + res[n-1][1]);
return res[n-1][0] + res[n-1][1];
};
来源：力扣（LeetCode）
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
