leetcode55. 跳跃游戏

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

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

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

示例 1:

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

示例 2:

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

 

思路：

就是干啊。。

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int pos=0;
        if(nums.size()==0||nums.size()==1)
            return true;
        int Res=funccore(nums,pos);
        if(Res==0)
            return false;
        else
            return true;
    }
    int funccore(vector<int>& nums,int pos){
        int Res=0;
        if(pos>=nums.size())
            return Res;
        for(int i=1;i<=nums[pos];i++)
        {
            int tmp=pos;
            tmp+=i;
            if(tmp==nums.size()-1)
                Res++;//计算出一共可以有几个方法
            else
                Res+=funccore(nums,tmp);
        }
        return Res;
    }
};

这样复杂度就比较高。应该是O（n*n）吧。。。不太会算,反正结果不对。

 

想要提高效率，应该是有一条路就return true；

class Solution {
public:
    bool funccore(vector<int>& nums,int pos){
        int Res=0;
        if(pos>=nums.size())
            return Res;
        for(int i=nums[pos];i>=1;i--)
        {
            if(pos+i==nums.size()-1)
                return true;
            else
            {
                Res =Res|| funccore(nums,pos+i);   
                if(Res==true)
                    return true;
            }
        }
        return Res;
    }

    bool canJump(vector<int>& nums) {
        int pos=0;
        if(nums.size()==0||nums.size()==1)
            return true;
        return funccore(nums,pos);
    }
};

还是有一个不通过。。。

 

正确思路：

贪心算法

i+nums[i]代表当前位置能走到的最远位置。

往前走的过程中不断更新从当前位置能走到哪里。

如果reach（到达的位置）大于当前位置能走的最大位置max_reach。那么就走不下去了。

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int len=nums.size();
        vector<int> nums_index;
        for(int i=0;i<len;i++)
            nums_index.push_back(i+nums[i]);//当前位置能走到的最大位置
        int reach=0;
        int max_reach=nums_index[0];//初始化
        while(reach<len&&reach<=max_reach)
//要么是到头了，要么是走不下去了（当前位置大于当前位置能到的最大位置）
        {
            if(max_reach<nums_index[reach])//更新最远位置
                max_reach=nums_index[reach];
            reach++;/往前走
        }
        if(reach >=len)  return true;
        else return false;
    }
};

参考：

https://blog.csdn.net/conniewu/article/details/80039238

高手博客：

https://blog.csdn.net/Scarlett_Guan/article/details/80156581