Leetcode55 跳跃游戏

问题描述：给定一个非负整数数组，你最初位于数组的第一个位置，
数组中的每个元素代表你在该位置可以跳跃的最大长度，判断你是否能够到达最后一个位置。
例：输入: [2,3,1,1,4]；输出: true
解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置
思路：

• 递归回溯

时间复杂度：o(2ⁿ)，详见官方题解
空间复杂度：o(n)

• 动态规划优化（自底向上）

时间复杂度：o(n²)
空间复杂度：o(2n)，信息表加回溯栈

• 动态规划优化（自顶向下）//消除回溯，时空间都优化

时间复杂度：o(n²)
空间复杂度：o(n)

• 贪心

时间复杂度：o(n)
空间复杂度：o(1)

//递归回溯
class Solution {
    public boolean canJump(int[] nums) {
        if(nums.length < 2) return true;
        return jump(nums, 0);
    }
    public boolean jump(int[] nums, int index){
        if(index+nums[index] >= nums.length-1)    return true;//可以到达尾位置
        for(int i = index+1; i <= index+nums[index]; ++i){//查找该位置可到达的所有位置
            if(jump(nums, i))  return true;//回溯
        }
        return false;
    }
}
//优化递归，选最大步数跳跃
class Solution {
    public boolean canJump(int[] nums) {
        if(nums.length < 2) return true;
        return jump(nums, 0);
    }
    public boolean jump(int[] nums, int position){
        if(position == nums.length-1)    return true;//到达尾位置
        int jumpMaxStep = Math.min(position+nums[position], nums.length-1);//最大长度设置为可到达的最远值和数组最大长度的取小值
        for(int i = jumpMaxStep; i > position; --i){//优化，先到最远位置，再向后寻找
            if(jump(nums, i))  return true;//如果该位置经过回溯可到达尾位置
        }
        return false;
    }
}
//进一步优化，在递归回溯中加入节点信息表，一旦某个节点回溯过判断为可能或不可能到达数组尾部，将其标记为坏/好节点，在后续回溯中一旦到达该节点直接利用该信息判断
enum inf{Good, Bad, Unknown}
class Solution {
    inf[] memo;//信息数组
    public boolean canJump(int[] nums) {
        int n = nums.length;
        if(n < 2) return true;
        memo = new inf[n];
        for(int i = 0; i < n-1; ++i){//初始化，除尾结点外全部标记为Unknown
            memo[i] = inf.Unknown;
        }
        memo[n-1] = inf.Good;
        return jump(nums, 0);//回溯
    }
    public boolean jump(int[] nums, int position){
        if(memo[position] != inf.Unknown)//该位置是否已经回溯过
            return memo[position] == inf.Good ? true : false;//是否可到达尾结点
        int jumpMaxStep = Math.min(position+nums[position], nums.length-1);
        for(int i = position+1; i <= jumpMaxStep; ++i){
            if(jump(nums, i)){//可到达尾结点，标记为Good
                memo[position] = inf.Good;
                return true;
            }
        }
        memo[position] = inf.Bad;//不可到达尾结点，标记为Bad
        return false;
    }
}
//在进一步优化，自顶向下（从右到左），利用右边已经更新的位置不断更新信息表，找到可到达尾部的元素，最后判断首位置是否标记为可到达尾位置
enum Inf {
    Good, Bad, Unknown
}
public class Solution {
    Inf[] memo;
    public boolean canJump(int[] nums) {
        memo = new Inf[nums.length];
        for (int i = 0; i < memo.length; i++) {//初始化信息表
            memo[i] = Inf.Unknown;
        }
        memo[memo.length - 1] = Inf.Good;

        for(int i = nums.length-2; i >= 0; --i){//从倒数第二位开始向左判断
            int step = Math.min(i+nums[i], nums.length-1);//当前位置可向右最远可跳的位置
            for(int j = i; j <= step; ++j){//判断当前位置的可跳位置中有无已标记位置
                if(memo[j] == Inf.Good){//存在可达位置可达尾位置，标记当前位置
                    memo[i] = Inf.Good;
                    break;
                }
            }
        }
        return memo[0] == Inf.Good;
    }
}
//贪心算法
class Solution {
    public boolean canJump(int[] nums) {
        if(nums.length < 2) return true;
        int lastPosition = nums.length - 1;
        for(int i = lastPosition - 1; i >= 0; --i){//向前寻找可以到达最左端的位置
            if(i+nums[i] >= lastPosition)    lastPosition = i;//不断更新可到达的最左端
        }
        return lastPosition == 0;//最后找到的位置为首位置，表明从首位置可到达尾位置，否则不可以
    }
}

Leetcode官方题解很详细：goto