第六章 - 高频考题(困难)
0975. 奇偶跳

题目地址 (975. 奇偶跳)

题目描述

1
给定一个整数数组 A,你可以从某一起始索引出发,跳跃一定次数。在你跳跃的过程中,第 1、3、5... 次跳跃称为奇数跳跃,而第 2、4、6... 次跳跃称为偶数跳跃。
2
3
你可以按以下方式从索引 i 向后跳转到索引 j(其中 i < j):
4
5
在进行奇数跳跃时(如,第 1,3,5... 次跳跃),你将会跳到索引 j,使得 A[i] <= A[j],A[j] 是可能的最小值。如果存在多个这样的索引 j,你只能跳到满足要求的最小索引 j 上。
6
在进行偶数跳跃时(如,第 2,4,6... 次跳跃),你将会跳到索引 j,使得 A[i] >= A[j],A[j] 是可能的最大值。如果存在多个这样的索引 j,你只能跳到满足要求的最小索引 j 上。
7
(对于某些索引 i,可能无法进行合乎要求的跳跃。)
8
如果从某一索引开始跳跃一定次数(可能是 0 次或多次),就可以到达数组的末尾(索引 A.length - 1),那么该索引就会被认为是好的起始索引。
9
10
返回好的起始索引的数量。
11
12
13
14
示例 1:
15
16
输入:[10,13,12,14,15]
17
输出:2
18
解释:
19
从起始索引 i = 0 出发,我们可以跳到 i = 2,(因为 A[2] 是 A[1],A[2],A[3],A[4] 中大于或等于 A[0] 的最小值),然后我们就无法继续跳下去了。
20
从起始索引 i = 1 和 i = 2 出发,我们可以跳到 i = 3,然后我们就无法继续跳下去了。
21
从起始索引 i = 3 出发,我们可以跳到 i = 4,到达数组末尾。
22
从起始索引 i = 4 出发,我们已经到达数组末尾。
23
总之,我们可以从 2 个不同的起始索引(i = 3, i = 4)出发,通过一定数量的跳跃到达数组末尾。
24
示例 2:
25
26
输入:[2,3,1,1,4]
27
输出:3
28
解释:
29
从起始索引 i=0 出发,我们依次可以跳到 i = 1,i = 2,i = 3:
30
31
在我们的第一次跳跃(奇数)中,我们先跳到 i = 1,因为 A[1] 是(A[1],A[2],A[3],A[4])中大于或等于 A[0] 的最小值。
32
33
在我们的第二次跳跃(偶数)中,我们从 i = 1 跳到 i = 2,因为 A[2] 是(A[2],A[3],A[4])中小于或等于 A[1] 的最大值。A[3] 也是最大的值,但 2 是一个较小的索引,所以我们只能跳到 i = 2,而不能跳到 i = 3。
34
35
在我们的第三次跳跃(奇数)中,我们从 i = 2 跳到 i = 3,因为 A[3] 是(A[3],A[4])中大于或等于 A[2] 的最小值。
36
37
我们不能从 i = 3 跳到 i = 4,所以起始索引 i = 0 不是好的起始索引。
38
39
类似地,我们可以推断:
40
从起始索引 i = 1 出发, 我们跳到 i = 4,这样我们就到达数组末尾。
41
从起始索引 i = 2 出发, 我们跳到 i = 3,然后我们就不能再跳了。
42
从起始索引 i = 3 出发, 我们跳到 i = 4,这样我们就到达数组末尾。
43
从起始索引 i = 4 出发,我们已经到达数组末尾。
44
总之,我们可以从 3 个不同的起始索引(i = 1, i = 3, i = 4)出发,通过一定数量的跳跃到达数组末尾。
45
示例 3:
46
47
输入:[5,1,3,4,2]
48
输出:3
49
解释:
50
我们可以从起始索引 1,2,4 出发到达数组末尾。
51
52
53
提示:
54
55
1 <= A.length <= 20000
56
0 <= A[i] < 100000
Copied!

前置知识

公司

  • 暂无

思路

题目要求我们从数组某一个索引出发交替跳高和跳低(奇偶跳),如果可以跳到末尾,则计数器加一,最终返回计数器的值。
这种题目一般都是倒着思考比较容易。因为我虽然不知道你从哪开始可以跳到最后,但是我知道最终被计算进返回值的一定是在数组末尾结束的
我们先尝试从题目给的例子打开思路。
以题目中的[10,13,12,14,15]为例。最终计入计数器的出发点一定是跳到了 15 上,15 这一步既可以是跳高(奇数跳)过来的,也可以是跳低(偶数跳)过来的。
  • 如果是跳高过来的,那么一定是 14,因此只有 14 的下一个最小的比其大(或等于)的是 15。
  • 不可能是跳低过来的,因为没有比它大的。而如果前面有比它大的,那一定是找一个数 x,x 的下一个最大的比其小(或等于)的是 15。
一开始我想到的是单调栈,单很快就发现这行不通。因为题目要求的并不是下一个比其大(或等于)的数,而是下一个最小的比其大(或等于)。
如果题目要求的是下一个比其大(或等于)的数。那么我可以写出如下的代码:
1
n = len(A)
2
next_higher, next_lower = [-1] * n, [-1] * n
3
4
stack = []
5
for i, a in enumerate(A):
6
while stack and A[stack[-1]] <= A[i]:
7
next_higher[stack.pop()] = i
8
stack.append(i)
9
stack = []
10
for i, a in enumerate(A):
11
while stack and A[stack[-1]] >= A[i]:
12
next_lower[stack.pop()] = i
13
stack.append(i)
Copied!
对上面代码不熟悉的朋友,可以看下我之前写的 单调栈专题
可是我们需要求的是下一个最小的比其大(或等于)呀。一种简单的方法是先对 A 进行排序再使用单调栈。比如我们进行升序排序,接下来只要遍历一次排好序的数组,同时结合单调栈即可。 由于已经进行了排序,因此后面的数一定是不小于前面的数的,且对于任意相邻的数 a 和 b,a 的最小的大于等于它本身的数就是 b,前提是 a 和 b 对应排序之前的索引 i 和 j 满足 i < j。这提示我们排序的时候需要额外记录原始索引。
代码:
1
A = sorted([a, i] for i, a in enumerate(A))
Copied!
这里有 1 个细节。即排序的时候如何处理相等情况,比如 a 和 b 相等,是保持之前的相对顺序还是逆序还是都可以?实际上,我们想希望的是保持之前的相对顺序,这样才不会错过相等的情况的解。因此我这里排序的是时候是以 [a, i] 形式保存的数据。
由于除了要处理跳高,我们仍然需要处理跳低。而最关键的是跳低也需要我们在 a 和 b 相等的情况下,保持之前的相对顺序。 因此就不能通过简单的排序一次处理。比如我们不能这么干:
1
class Solution:
2
def oddEvenJumps(self, A):
3
n = len(A)
4
next_higher, next_lower = [0] * n, [0] * n
5
A = sorted([a, i] for i, a in enumerate(A))
6
7
stack = []
8
for _, i in A:
9
# it means stack[-1]'s next bigger(or equal) is i
10
while stack and stack[-1] < i:
11
next_higher[stack.pop()] = i
12
stack.append(i)
13
14
stack = []
15
for _, i in A[::-1]:
16
# it means stack[-1]'s next smaller(or equal) is i
17
while stack and stack[-1] < i:
18
next_lower[stack.pop()] = i
19
stack.append(i)
20
21
# ...
Copied!
解决这个问题的方法最简单的莫过于使用两次排序,具体见下方代码区。
现在已经有了两个数组,这两个数组可以帮助我们
  • 快速找到下一个最小的比其大(或等于)的数。(奇数跳)
  • 快速找到下一个最大的比其小(或等于)的数。(偶数跳)
数据已经预处理完毕。接下来,只需要从结果倒推即可。这提示我们从后往前遍历。
算法:
  • 使用前面的方法预处理出 next_higher 和 next_lower
  • 使用两个数组 higher 和 lower。higher[i] 表示是否可从 i 开始通过跳高的方式奇偶跳到达数组最后一项,lower 也是类似。
  • 从后往前倒推遍历。如果 lower[next_higher[i]] 为 true 说明 i 是可以通过跳高的方式奇偶跳到达数组最后一项的。higher[next_lower[i]] 也是类似。
  • 最后返回 higher 中 为 true 的个数。

代码

代码支持: Python3
Python Code:
1
class Solution:
2
def oddEvenJumps(self, A):
3
n = len(A)
4
next_higher, next_lower = [0] * n, [0] * n
5
6
stack = []
7
for _, i in sorted([a, i] for i, a in enumerate(A)):
8
# it means stack[-1]'s next bigger(or equal) is i
9
while stack and stack[-1] < i:
10
next_higher[stack.pop()] = i
11
stack.append(i)
12
13
stack = []
14
for _, i in sorted([-a, i] for i, a in enumerate(A)):
15
# it means stack[-1]'s next smaller(or equal) is i
16
while stack and stack[-1] < i:
17
next_lower[stack.pop()] = i
18
stack.append(i)
19
20
higher, lower = [False] * n, [False] * n
21
higher[-1] = lower[-1] = True
22
ans = 1
23
for i in range(n - 2, -1, -1):
24
higher[i] = lower[next_higher[i]]
25
lower[i] = higher[next_lower[i]]
26
ans += higher[i]
27
return ans
Copied!
复杂度分析
令 N 为数组 A 的长度。
  • 时间复杂度:$O(NlogN)$
  • 空间复杂度:$O(N)$
有的同学好奇为什么不考虑 lower。类似:
1
ans = 1
2
for i in range(n - 2, -1, -1):
3
higher[i] = lower[next_higher[i]]
4
lower[i] = higher[next_lower[i]]
5
ans += higher[i] or lower[i]
6
return ans
Copied!
根本原因是题目要求我们必须从奇数跳开始,而不是能偶数跳开始。如果题目不限制奇数跳和偶数跳,你可以自己自由选择的话,就必须使用上面的代码啦。
更多题解可以访问我的 LeetCode 题解仓库:https://github.com/azl397985856/leetcode 。 目前已经 37K star 啦。
关注公众号力扣加加,努力用清晰直白的语言还原解题思路,并且有大量图解,手把手教你识别套路,高效刷题。