LeetCode：55. Jump Game（跳远比赛）
文章最前： 我是Octopus，这个名字来源于我的中文名--章鱼；我热爱编程、热爱算法、热爱开源。所有源码在我的个人github ；这博客是记录我学习的点点滴滴，如果您对 Python、Java、AI、算法有兴趣，可以关注我的动态，一起学习，共同进步。
相关文章：
- LeetCode：55. Jump Game（跳远比赛）
- Leetcode：300. Longest Increasing Subsequence（最大增长序列）
- LeetCode：560. Subarray Sum Equals K（找出数组中连续子串和等于k）
文章目录：
题目描述：
方法1：
java实现方法:
python实现方法：
方法2
java实现方法：
python实现方法：
源码github地址：https://github.com/zhangyu345293721/leetcode
题目描述：
给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4]
输出: true解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置。
示例 2:
输入: [3,2,1,0,4]
输出: false解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
方法1：
我们可以用贪心的方法解决这个问题。
设想一下，对于数组中的任意一个位置 yy，我们如何判断它是否可以到达？根据题目的描述，只要存在一个位置 xx，它本身可以到达，并且它跳跃的最大长度为 x +nums[x]，这个值大于等于 yy，即 x + nums[x]≥y，那么位置 yy 也可以到达。
换句话说，对于每一个可以到达的位置 xx，它使得 x+1, x+2, ,⋯,x+nums[x] 这些连续的位置都可以到达。
这样以来，我们依次遍历数组中的每一个位置，并实时维护 最远可以到达的位置。对于当前遍历到的位置 xx，如果它在 最远可以到达的位置 的范围内，那么我们就可以从起点通过若干次跳跃到达该位置，因此我们可以用 x + nums[x] 更新 最远可以到达的位置。
在遍历的过程中，如果 最远可以到达的位置 大于等于数组中的最后一个位置，那就说明最后一个位置可达，我们就可以直接返回 True 作为答案。反之，如果在遍历结束后，最后一个位置仍然不可达，我们就返回 False 作为答案。
以题目中的示例一：[2, 3, 1, 1, 4]
为例：
我们一开始在位置 00，可以跳跃的最大长度为 22，因此最远可以到达的位置被更新为 22；
我们遍历到位置 11，由于 1≤2，因此位置 11 可达。我们用 11 加上它可以跳跃的最大长度 33，将最远可以到达的位置更新为 44。由于 44 大于等于最后一个位置 44，因此我们直接返回 True。
我们再来看看题目中的示例二：[3, 2, 1, 0, 4]
我们一开始在位置 00，可以跳跃的最大长度为 33，因此最远可以到达的位置被更新为 33；
我们遍历到位置 11，由于 1≤3，因此位置 11 可达，加上它可以跳跃的最大长度 22 得到 33，没有超过最远可以到达的位置；
位置 22、位置 33 同理，最远可以到达的位置不会被更新；
我们遍历到位置 44，由于 4 > 34>3，因此位置 44 不可达，我们也就不考虑它可以跳跃的最大长度了。
在遍历完成之后，位置 44 仍然不可达，因此我们返回 False。
java实现方法:
public boolean canJump(int[] nums) {
int n = nums.length;
int rightmost = 0;
for (int i = 0; i < n; ++i) {
if (i <= rightmost) {
rightmost = Math.max(rightmost, i + nums[i]);
if (rightmost >= n - 1) {
return true;
}
}
}
return false;
}
时间复杂度：O(n)
空间复杂度：O(1)
python实现方法：
def canJump(self, nums: List[int]) -> bool:
n, rightmost = len(nums), 0
for i in range(n):
if i <= rightmost:
rightmost = max(rightmost, i + nums[i])
if rightmost >= n - 1:
return True
return False时间复杂度：O(n)
空间复杂度：O(1)
方法2
根据题目，可以总结出，当你不管怎么跳，都要经过0时，也就是0是你的必经之路时，是跳不出去数组的。所以只要找到一条可以跳出0 的路径，那么就可以跳跃到最后一位。
那么如何判断是否能跳出0呢？设当前0的索引为index，用i遍历index-1至0，找到一个数大于index-i即可跳出0
java实现方法：
/**
* 跳步游戏
*
* @param nums 数组
* @return 布尔值
*/
public boolean canJump4(int[] nums) {
if (nums.length == 1) {
return true;
}
if (nums == null || nums[0] == 0) {
return false;
}
for (int i = 0; i < nums.length - 1; i++) {
if (nums[i] == 0) {
boolean flag = jumpFlag(nums, i);
if (flag) {
continue;
} else {
return false;
}
}
}
return true;
}
/**
* 判断是否能跳过0
*
* @param nums 数组
* @param i 位置
* @return 布尔值
*/
private boolean jumpFlag(int[] nums, int i) {
for (int j = i - 1; j >= 0; j--) {
if (nums[j] > i - j) {
return true;
}
}
return false;
}时间复杂度：O(n)
空间复杂度：O(1)
python实现方法：
def jump_flag(arr: List[int], i: int) -> bool:
'''
能不能跳过0点
Args:
arr: 数组
i: 位置i
Returns:
布尔值
'''
j = i
while j > 0:
if arr[j] > i - j:
return True
j -= 1
return False
def get_judge_jump_arr4(arr: List[int]) -> bool:
'''
跳远数组
Args:
arr: 数组
Returns:
是否能调到最后，布尔值
'''''
if len(arr) < 2:
return True
if arr == None or arr[0] == 0:
return True
for i in range(len(arr)):
if arr[i] == 0:
flag = jump_flag(arr, i)
if flag:
continue
else:
return flag
return True
时间复杂度：O(n)
空间复杂度：O(1)