题目:
给定一个非负整数数组,你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:
输入: [2,3,1,1,4]
输出: true
解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。
示例 2:
输入: [3,2,1,0,4]
输出: false
解释: 无论怎样,你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 , 所以你永远不可能到达最后一个位置。
解法一:贪心法
每次选择最远能达到的地方,假设从某一点最远可以到达A点,那么A点之前的所有点都是可以到达的。所以我们只要不断的更新最远可达到的点,然后看是否最远的点超过了终点即可。
Java
class Solution {
public boolean canJump(int[] nums) {
int max = 0, i = 0;
for (i = 0; i <= max && i < nums.length; i++) {
max = Math.max(max, nums[i]+i);
}
return i == nums.length;
}
}
执行用时:8 ms
Python
class Solution:
def canJump(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
maxpos = 0
result = False
for i in range(len(nums)-1):
if maxpos<i:
return False
maxpos = max(maxpos,nums[i]+i)
return True if maxpos >= len(nums)-1 else False
执行用时:68 ms
解法二:动态规划
Java
public class Solution {
public boolean canJump(int[] A) {
boolean[] can = new boolean[A.length];
can[0] = true;
for (int i = 1; i < A.length; i++) {
for (int j = 0; j < i; j++) {
if (can[j] && j + A[j] >= i) {
can[i] = true;
break;
}
}
}
return can[A.length - 1];
}
}
执行用时:272 ms (好慢)
Python
class Solution:
def canJump(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
n = len(nums)
dp = [False] * n
dp[-1] = True
for i in range(n - 2, -1, -1):
dp[i] = any(
dp[i + j] if i + j < n else True
for j in range(1, nums[i] + 1)
)
return dp[0]
超出时间限制
看来本题还是使用贪心法比较好。。
贪心和DP的比较:
贪心算法(又称贪婪算法)是指,在对问题求解时,总是做出在当前看来最好的选择。也就是说,不从整体最优上加以考虑,他所作出的是在某种意义上的局部最优解。贪心算法和动态规划算法都是由局部最优导出全局最优,这里不得不比较下二者的区别
贪心算法:
1.贪心算法中,作出的每步贪心决策都无法改变,因为贪心策略是由上一步的最优解推导下一步的最优解,而上一部之前的最优解则不作保留。
2.由(1)中的介绍,可以知道贪心法正确的条件是:每一步的最优解一定包含上一步的最优解
动态规划算法:
1.全局最优解中一定包含某个局部最优解,但不一定包含前一个局部最优解,因此需要记录之前的所有最优解
2.动态规划的关键是状态转移方程,即如何由以求出的局部最优解来推导全局最优解
3.边界条件:即最简单的,可以直接得出的局部最优解