算法学习——leetcode55. 跳跃游戏（贪心算法）

题目:

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

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

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

示例 1:

输入: [2,3,1,1,4]
输出: true
解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。

示例 2:

输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。

解题思路：

起初的想法是从目标来看，根据结果找答案，先得到总长度len（即数组长度-1），然后从头遍历，看能不能从nums[0]直接到达尾部，如果不能，再看后面的。即：

[2,3,1,1,4]  到达尾部需要走四步，我想先看能不能（4）到达，然后（1，3）到达，（2，2）到达，前面的2可以再分，（3，1）到达，3可以再分，因为我的思路是倒着来，找到了能三步到达的之后，就把后面的截断，形成了一个新的数组，进行递归。（感觉像是在尽量找到最优解，使得走尽量少的步就能到达，但其实贪心算法是不用找到最优解的，当然这个问题也只让回答是否，所以不用求得最优解，代码2是我的想法）

但是这种办法时间复杂度太大，当数组长度超过一定大小之后，就会超出时间限制。

看了评论之后，发现了代码1的时间复杂度为O(n)，算法思想简单，就是直接从后往前遍历，能跳跃，就截断继续遍历。

 

代码1：

class Solution {
public:
    bool canJump(vector<int>& nums) {
       int n=1;
        for(int i=nums.size()-2;i>=0;i--){
            if(nums[i]>=n)
                n=1;
            else{
                n++;
            }
            if(i==0&&n>1)
                return false;
        }
        return true;
    }
};

 

执行用时 : 20 ms, 在Jump Game的C++提交中击败了27.86% 的用户

内存消耗 : 10.1 MB, 在Jump Game的C++提交中击败了0.87% 的用户

代码2：

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int leftlen = calJump(nums,nums.size()-1);
        if(leftlen == 0)
            return true;
        else
            return false;
    }
    int calJump(vector<int>& nums,int x){
        int len = x;
        int leftlen = len;
        for(int i=0;i<x;i++){
            if(nums[i]<leftlen){
                if(i!=x-1){
                    leftlen --;
                }
            }
            else if(nums[i]>=leftlen){
                leftlen = i;
                if(i != 0)
                   leftlen = calJump(nums,i);
            }
        }
        return leftlen;
    }
};

超出时间限制

感觉这个代码还可以优化，但是暂时想不出来了，先放这里吧