JAVA程序设计：奇偶跳（LeetCode：975）

给定一个整数数组 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 出发到达数组末尾。
 

提示：

1 <= A.length <= 20000
0 <= A[i] < 100000

方法一：单调栈。

我们仅考虑第奇数次跳跃（偶数次跳跃的分析一模一样），从题目分析所得，对于第奇数次跳跃，其下一个位置是唯一的，一定是该位置后边并且值大于它的最小值。为了满足这一条件，我们需要首先对数组A从小到大排序，同时保存每个值的初始索引，之后我们维护一个单调递减的单调栈。该单调栈存储的是值所对应的索引。因为此时的数组A是单调递增的，所以栈顶元素是否弹出的条件为栈顶存储的索引小于当前要加入元素的索引。

class Solution {
    public int oddEvenJumps(int[] A) {
    	
    	int n=A.length;
    	int[][] a=new int[n][2];
    	int[] oddnext=new int[n];
    	int[] evennext=new int[n];
    	
    	for(int i=0;i<n;i++) {
    		a[i][0]=i;
    		a[i][1]=A[i];
    	}
    	
    	Arrays.parallelSort(a, (aa,bb)->aa[1]==bb[1]?aa[0]-bb[0]:aa[1]-bb[1]);
    	oddnext=make(a);
    	
    	for(int i=0;i<n;i++) {
    		a[i][0]=i;
    		a[i][1]=-A[i];
    	}
    	
    	Arrays.parallelSort(a, (aa,bb)->aa[1]==bb[1]?aa[0]-bb[0]:aa[1]-bb[1]);
    	evennext=make(a);
    	
    	boolean[] odd=new boolean[n];
    	boolean[] even=new boolean[n];
    	
    	odd[n-1]=even[n-1]=true;
    	
    	for(int i=n-2;i>=0;i--) {
    		if(oddnext[i]!=-1)
    			odd[i]=even[oddnext[i]];
    		if(evennext[i]!=-1)
    			even[i]=odd[evennext[i]];
    	}
    	
    	int ans=0;
    	
    	for(int i=0;i<n;i++)
    		if(odd[i])
    			ans++;
    	
    	return ans;
    	
    }
    
    private int[] make(int[][] arr) {
    	
    	int n=arr.length;
    	int[] ans=new int[n];
    	Stack<Integer> st=new Stack<>();
    	
    	Arrays.fill(ans, -1);
    	
    	for(int i=0;i<n;i++) {
    		while(!st.isEmpty() && arr[i][0]>st.peek())
    			ans[st.pop()]=arr[i][0];
    		st.add(arr[i][0]);
    	}
    	
    	return ans;
    	
    }
}

方法二：TreeMap

在java中，有一个维护有序数据的绝佳数据结构TreeMap，我们通过TreeMap将值和对应索引存储起来，从 i = N-2 到 i = 0 的遍历过程中，对于 v = A[i]， 我们想知道比它略大一点和略小一点的元素是谁。 TreeMap.lowerKey 与 TreeMap.higherKey 函数就是用来做这样一件事情的。

class Solution {
    public int oddEvenJumps(int[] A) {
    	
    	int n=A.length;
    	
    	if(n<=1) return n;
    	
    	int ans=0;
    	boolean[] odd=new boolean[n];
    	boolean[] even=new boolean[n];
    	TreeMap<Integer,Integer> map=new TreeMap<>();
    	
    	odd[n-1]=even[n-1]=true;
    	map.put(A[n-1], n-1);
    	
    	for(int i=n-2;i>=0;i--) {
    		int v=A[i];
    		if(map.containsKey(v)) {
    			odd[i]=even[map.get(v)];
    			even[i]=odd[map.get(v)];
    		}
    		else {
    			Integer lower=map.lowerKey(v);
    			Integer higher=map.higherKey(v);
    			
    			if(lower!=null)
    				even[i]=odd[map.get(lower)];
    			if(higher!=null)
    				odd[i]=even[map.get(higher)];
    		}
    		map.put(v, i);
    	}
    	
    	for(int i=0;i<n;i++)
    		if(odd[i])
    			ans++;
    	
    	return ans;
    	
    }
}