萌新刷题之跳跃游戏

题目：

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个位置。

示例 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.边界条件：即最简单的，可以直接得出的局部最优解