LeetCode 55 跳跃游戏

1.自己的做法，递归

class Solution {
    public boolean canJump(int[] nums) {
        return cJ(nums,0);
    }
    public boolean cJ(int[] nums,int begin){
        int max=0,pos=begin;
        for(int i=begin+1;i<nums.length&&i<=begin+nums[begin];i++){
            if(nums[i]+i>max){
                max=nums[i]+i;
                pos=i;
            }
        }
        if(pos==nums.length-1){
            return true;
        }else if(pos==begin){
            return false;
        }else{
            return cJ(nums,pos);
        }
    }
}

这个题用的是贪心算法的思想，每次begin的选择都是在目前的选择下做出最优的选择

begin从0开始，在这里用一个例子来说明

[2,3,1,5,4,0,0,0,0,1]

1.此时，begin=0，nums[i]=2,这意味着你可以调到i=1和i=2的位置，也就是begin+nums[begin]

这就是判断条件i<=begin+nums[begin]的来历

2.此时，你只要选择i<=begin+nums[begin]，在这个范围内，哪个位置作为下个位置的起跳点，此时，你当然是选择最远的最好了对不对？

但是，当时我纠结一个点，我可以从3跳到4，也可以从1跳到5，当时我自己把自己禁锢住了，就一股脑的觉得每次就要跳nums[i]，但是其实从3也可以跳到5，不知道有没有人会和我一样犯糊涂

3.还有一个问题，是在最后return时，pos==nums.length-1和pos==begin的先后问题，我原来不是这样放，是pos==begin放在最前面，我当时觉得，如果最后pos==begin，证明它没法往下跳了，但是如果数组为[0]呢

其实这时候就已经成功了，pos==nums.length-1的同时pos==begin

下面又优化了一下判断条件，如果可以从begin跳到最后，就不进循环了，浪费时间

class Solution {
    public boolean canJump(int[] nums) {
        return cJ(nums,0);
    }
    public boolean cJ(int[] nums,int begin){
        if(begin+nums[begin]>=nums.length-1) return true;
        int max=0,pos=begin;
        for(int i=begin+1;i<nums.length&&i<=begin+nums[begin];i++){
            if(nums[i]+i>max){
                max=nums[i]+i;
                pos=i;
            }
        }
        if(pos==begin){
            return false;
        }else{
            return cJ(nums,pos);
        }
    }
}

 

class Solution {
    public boolean canJump(int[] nums) {
        int max,pos;
        for(int i=0;i<nums.length;i=pos){
            max=0;
            pos=i;
            for(int j=i+1;j<nums.length&&j<=i+nums[i];j++){
                if(nums[j]+j>max){
                    max=nums[j]+j;
                    pos=j;
                }
            }
            if(pos==nums.length-1){
                return true;
            }else if(pos==i){
                return false;
            }
        }
        return false;
    }
}

 

一样的贪心算法，就是优化了一下，牺牲时间，提高空间

2.看了官方题解，感觉自己想的有点复杂，哎，太蠢了

class Solution {
    public boolean canJump(int[] nums) {
        int max=0;
        for(int i=0;i<nums.length;i++){
            if(i<=max){
                max=Math.max(max,nums[i]+i);
                if(max>=nums.length-1) return true;
            }
        }
        return false;
    }
}

 这个max，就是可以跳到的最远的地方，我感觉我的递归为啥比这个用时少？可能体现在那个中间return false上了