给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4]
输出: true
解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。
示例 2:
输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
解题思路
这个问题非常简单，我们通过递归很容易解决。我们想要知道能否到达index，那么只需要知道index之前的元素是不是有nums[i]+i >= index for i in range(index)，也就是index之前是不是有元素可以到达index，如果存在，那么我们只需要判断是否有元素能到i，如果也成立，那么我们返回True，否则我们返回False。例如
3 2 1 0 4
|<- i ->| index
class Solution:
def canJump(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
nums_len = len(nums)
return self._canJump(nums, nums_len - 1)
def _canJump(self, nums, index):
if index == 0:
return True
for i in range(index):
if nums[i] + i >= index and self._canJump(nums, i):
return True
return False
我们也很容易通过记忆化搜索的方法对这个问题优化
class Solution:
def canJump(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
nums_len = len(nums)
mem = [None]*nums_len
mem[0] = True
return self._canJump(nums, nums_len - 1, mem)
def _canJump(self, nums, index, mem):
if mem[index] != None:
return mem[index]
for i in range(index):
if nums[i] + i >= index and self._canJump(nums, i, mem):
mem[i] = True
return True
mem[i] = False
return False
但是这种做法在提交的时候超时了，我们只能想其他的办法。有没有更好的呢？我们想想通过动态规划能否解决这个问题，其实思路和记忆化搜索是一样的。
class Solution:
def canJump(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
nums_len = len(nums)
mem = [False]*nums_len
mem[0] = True
for i in range(1,nums_len):
for j in range(i):
if mem[j] and nums[j] + j >= i:
mem[i] = True
break
return mem[-1]
所以可想而知这样做也就超时了，显然我们应该是忽略了什么可以剪枝的条件。实际上，我们只要反过来思考就可以了。对于能否到达index的这个问题，我们需要知道对于0<=i<index是否可以到达index，并且同时我们能否到达i。这个时候，我们i不是从头开始考虑，而是从后往前考虑的话，会节省大量的时间。例如
1 1 1 1 1 1
index
true ?
我们这是时候知道可以到达index-1了，我们只需要知道index-1能否到达index就可以啦。而不是又要从头开始遍历一次。所以只要将代码稍微修改一下即可。
class Solution:
def canJump(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
nums_len = len(nums)
mem = [False]*nums_len
mem[0] = True
for i in range(1,nums_len):
for j in range(i,-1,-1):
if mem[j] and nums[j] + j >= i:
mem[i] = True
break
return mem[-1]
同样的修改对于记忆化搜索也是有效的。
对于这个问题最好的解法是贪心算法。对于index的位置，我们将index之前的元素值和其索引值相加
3 2 1 0 4
3 3 3 3 index
然后我们计算之前和的最大值m，如果index>m，那么自然不能到达index了。对于所有[0:len(nums))都满足上述条件的话，那么自然就成立了。
总体的思路就是，我们希望前面的步子迈大一点，这样可以给后面留有更多的余地。
class Solution:
def canJump(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
m = 0
for i, num in enumerate(nums):
if i > m:
return False
m = max(m, i + num)
return True
我将该问题的其他语言版本添加到了我的GitHub Leetcode
如有问题，希望大家指出！！！