【算法刷题】leetcode jump game

最新推荐文章于 2022-05-06 17:05:28 发布

Neo_dot

最新推荐文章于 2022-05-06 17:05:28 发布

阅读量282

点赞数

分类专栏：算法题

本文链接：https://blog.csdn.net/Neo_dot/article/details/80951112

版权

算法题专栏收录该内容

27 篇文章

订阅专栏

本文探讨了两种不同难度级别的跳跃游戏算法问题。基础版问题旨在判断能否从数组起始位置达到末尾，通过贪心算法实现；进阶版则关注如何以最少步骤到达终点，提供了动态规划及优化后的贪心算法解决方案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

基础版：是否能到达

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Determine if you are able to reach the last index.

For example:
A =[2,3,1,1,4], returntrue.

A =[3,2,1,0,4], returnfalse.

利用贪心

    bool canJump(int A[], int n) {
        if(A==nullptr)
            return false;
        int maxnum = A[0];
        for(int i=1;i<n;++i)
        {
            if(i<=maxnum)
            {
                int n=i+A[i];
                maxnum = max(maxnum,n);
            }
        }
        if(maxnum <(n-1))
            return false;
        
        return true;
    }

进阶版到达最后一个最少的步数

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Your goal is to reach the last index in the minimum number of jumps.

For example:
Given array A =[2,3,1,1,4]

The minimum number of jumps to reach the last index is2. (Jump1step from index 0 to 1, then3steps to the last index.)

首先利用了动态规划，dp[i]表示到达当前位置最小的步数，代码如下

    int jump(int A[], int n) {
        if(A==nullptr)
            return 0;
        int* dp = new int[n];
        dp[0]=0;
        for(int i=1;i<n;++i)
        {
            dp[i] = n+1;
            for(int j=0;j<i;++j)
            {
                if(i<=j+A[j])
                {
                    int temp = dp[j]+1;
                    dp[i] = min(dp[i],temp);
                }
            }
            
        }
        int res = dp[n-1];
        delete []dp;
        return res;
    }

在牛客网上没有提示超时，过了，但是在网上看到说在leetcode上利用动态规划会超时，最好的方法还是利用贪心：

cur是当前能到达的最远位置，即最远能覆盖的位置，last是上一步能到达的最远位置，遍历数组，用i + nums[i]更新cur，然后判断如果当前位置超过了last，即上一步能到达的最远位置，说明需要再跳一次了,并更新last

    int jump(int A[], int n) {
        if(A==nullptr)
            return 0;
        int res(0),last(0),cur(0);
        for(int i=0;i<n;++i)
        {
            
            if(i>last)
            {
                ++res;
                last = cur;
            }
            cur=max(cur,i+A[i]);
        }
        
        
        return res;
    }