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

news2024/11/19 1:29:51

在这里插入图片描述

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

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

🎉欢迎 👍点赞✍评论⭐收藏

在这里插入图片描述

🔎 算法领域知识 🔎

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

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

在这里插入图片描述

题目如下：

给你一个非负整数数组 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⁵

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

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

具体实现逻辑如下：

初始化一个变量 maxPosition 为 0，表示当前能够跳跃的最远位置。
遍历数组 nums，对于当前位置 i，判断是否超过了当前能够跳跃的最远位置 maxPosition，如果超过了，则说明无法到达最后一个下标，返回 false。
更新 maxPosition 为当前位置 i 和当前位置能够跳跃的最大长度之和中的较大值。
如果最后 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 方法，并打印出结果。

执行过程如下：

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