55. 跳跃游戏

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

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

判断你是否能够到达最后一个下标。

示例 1：

输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

示例 2：

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

提示：

• 1 <= nums.length <= 3 * 10^4
• 0 <= nums[i] <= 10^5

动态规划

class Solution {
    public boolean canJump(int[] nums) {
        int n = nums.length;
        if (n == 0) return false;

        // 初始化dp数组，dp[i]表示从索引i开始能够到达的最远距离，即索引位置。
        int[] dp = new int[n];
        dp[0] = nums[0];  // 初始位置能够到达的最远距离

        // 遍历数组，更新每个位置i的最远到达距离
        for (int i = 1; i < n; i++) {
            // 只有i在前一个位置的可达范围内，才更新dp[i]。重点。
            if (i <= dp[i - 1]) {
                // 重点。
                dp[i] = Math.max(dp[i - 1], i + nums[i]);
                // 如果最远距离已经达到或超过最后一个位置，返回true
                if (dp[i] >= n - 1) {
                    return true;
                }
            } else {
                // 如果当前位置不可达，即与前面的位置连不上，直接返回false。重点。
                return false;
            }
        }

        // 检查最终位置是否可达，可以直接返回true。注意这个返回是有用的，不是说凑个数，随便返回一个。例如输入[0]，进不去for循环，从而会返回这里的结果。这是因为i是从1开始的，而这是因为我们需要计算i-1。
        return dp[n - 1] >= n - 1;
    }
}

• 时间复杂度O(n)，空间复杂度O(n)

贪心

相当于滚动更新。

public class Solution {
    public boolean canJump(int[] nums) {
        int n = nums.length;
        int rightmost = 0;
        
        for (int i = 0; i < n; ++i) {
            // 只要 i 是可达的，就计算当前元素可达的更远距离。
            if (i <= rightmost) {
                // 重点。
                rightmost = Math.max(rightmost, i + nums[i]);
                if (rightmost >= n - 1) {
                    return true;
                }
            } else {
                break;
            }
        }
        
        return false;
    }
}

或者

class Solution {
    public boolean canJump(int[] nums) {
        int n = nums.length;
        int farthest = 0;
        for (int i = 0; i < n - 1; i++) { // i < n - 1 不是 i < n;
            // 不断计算前 i 个位置能跳到的最远距离，一定是前 i 个位置，不能只计算当前位置能跳的最远距离，
            // 例如 3 4 0 3，虽然第三个数是 0，但是前面的位置可以跳得更远，所以不用担心。
            farthest = Math.max(farthest, i + nums[i]);
            // 可能碰到了 0，卡住跳不动了
            if (farthest == i) { // 即 nums[i] = 0。重点。
                return false;
            }
        }
        // 原代码是 return farthest >= n - 1; 其实只要 farthest 大于 i，那么 farthest 就一定可以达到 n - 1; 所以直接写 true 就可以了。
        return true;
    }
}

时间复杂度O(n)，空间复杂度O(1)