前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >萌新刷题之跳跃游戏

萌新刷题之跳跃游戏

作者头像
小歪
发布2018-12-24 17:18:33
3580
发布2018-12-24 17:18:33
举报

题目:

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

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

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

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

本文参与 腾讯云自媒体分享计划,分享自微信公众号。
原始发表:2018-12-03,如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 Python爬虫与算法进阶 微信公众号,前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体分享计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档