跳跃游戏，经典算法实战。

🏆作者简介，普修罗双战士，一直追求不断学习和成长，在技术的道路上持续探索和实践。

🏆多年互联网行业从业经验，历任核心研发工程师，项目技术负责人。

🎉欢迎 👍点赞?评论?收藏

🔎 算法领域知识 🔎

链接	专栏
分发糖果	算法专栏
买卖股票的最佳时机	算法专栏
跳跃游戏	算法专栏

经典算法题 之 买卖股票的最佳时机

题目如下：

给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。

判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。

示例 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 <= 10⁴
• 0 <= nums[i] <= 10⁵

解答这道题，可以使用 贪心算法 进行解决。

为了判断是否能够到达最后一个下标，我们可以使用贪心算法的思想来实现。贪心算法的基本思想是每一步都选择当前能够跳跃最远的位置。

具体实现逻辑如下：

1. 初始化一个变量 maxPosition 为 0，表示当前能够跳跃的最远位置。
2. 遍历数组 nums，对于当前位置 i，判断是否超过了当前能够跳跃的最远位置 maxPosition，如果超过了，则说明无法到达最后一个下标，返回 false。
3. 更新 maxPosition 为当前位置 i 和当前位置能够跳跃的最大长度之和中的较大值。
4. 如果最后 maxPosition 大于等于数组的最后一个下标（即 nums.length - 1），则说明能够到达最后一个下标，返回 true；否则，返回 false。

以下是用Java代码实现的示例：

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

public class Main {
    public static void main(String[] args) {
        Solution solution = new Solution();
        int[] nums = {2, 3, 1, 1, 4};
        boolean result = solution.canJump(nums);
        System.out.println(result); // 输出 true
        
        int[] nums2 = {3, 2, 1, 0, 4};
        boolean result2 = solution.canJump(nums2);
        System.out.println(result2); // 输出 false
    }
}

在上面的代码中，我们首先定义了一个 Solution 类，其中包含了 canJump 方法，用于判断是否能够到达最后一个下标。然后，在 Main 类的 main 方法中，我们创建了一个 Solution 对象，并对示例数组 nums 和 nums2 分别调用 canJump 方法，并打印出结果。

执行过程如下：

1. 首先，将 nums 传入 canJump 方法中。
2. 在 canJump 方法中，初始化 maxPosition 为 0。
3. 进入循环，此时 i 为 0，判断是否超过了 maxPosition，因为初始时 maxPosition 为 0，所以不超过。
4. 更新 maxPosition 为 0 和 i + nums[i] 的较大值，即 0 和 2，所以 maxPosition 更新为 2。
5. 继续下一轮循环，此时 i 为 1，判断是否超过了 maxPosition，因为此时 i 为 1，而 maxPosition 为 2，所以不超过。
6. 更新 maxPosition 为 2 和 i + nums[i] 的较大值，即 2 和 1 + 3，所以 maxPosition 更新为 4。
7. 继续下一轮循环，此时 i 为 2，判断是否超过了 maxPosition，因为此时 i 为 2，而 maxPosition 为 4，所以不超过。
8. 更新 maxPosition 为 4 和 i + nums[i] 的较大值，即 4 和 2 + 1，所以 maxPosition 仍然为 4。
9. 继续下一轮循环，此时 i 为 3，判断是否超过了 maxPosition，因为此时 i 为 3，而 maxPosition 为 4，所以不超过。
10. 更新 maxPosition 为 4 和 i + nums[i] 的较大值，即 4 和 3 + 1，所以 maxPosition 仍然为 4。
11. 继续下一轮循环，此时 i 为 4，判断是否超过了 maxPosition，因为此时 i 为 4，而 maxPosition 为 4，所以不超过。
12. 更新 maxPosition 为 4 和 i + nums[i] 的较大值，即 4 和 4 + 4，所以 maxPosition 更新为 8。
13. 循环结束，因为 maxPosition 大于等于数组的最后一个下标，即 4，所以返回 true。

对于示例数组 nums2，执行过程类似，只是在第四步时 maxPosition 更新为 3，此时无法到达最后一个下标，因此返回 false。

通过这个示例题目，你可以练习使用贪心算法来解决实际问题，并且可以加深对Java代码实现的掌握。希望这个例子能够帮助你更好地理解算法和数据结构的基本原理和应用。

🏆关注作者，普修罗双战士，给你不一样的技术体验，一起在技术领域扶摇直上九万里，共筑坚如磐石的权。

🎉欢迎 👍点赞?评论?收藏