动态规划算法贪心算法之跳跃游戏详细解读（附带Java代码解读）

最新推荐文章于 2024-09-24 16:23:12 发布

Katie。

最新推荐文章于 2024-09-24 16:23:12 发布

阅读量945

点赞数 21

分类专栏：算法分析文章标签：算法动态规划游戏

本文链接：https://blog.csdn.net/m0_61840987/article/details/142091724

版权

算法分析专栏收录该内容

87 篇文章 0 订阅

订阅专栏

跳跃游戏（Jump Game）是一道经典的贪心算法和动态规划问题，旨在判断是否可以通过跳跃从数组的起始位置到达数组的末尾。该问题有两种常见的形式：跳跃游戏 I 和跳跃游戏 II。

1. 跳跃游戏 I 问题描述

给定一个非负整数数组 nums，数组中的每个元素表示在该位置最多可以跳跃的步数。起始位置在数组的第一个元素处。你的任务是判断是否可以通过跳跃到达数组的最后一个位置。

示例：

输入：nums = [2, 3, 1, 1, 4]
输出：true
解释：我们可以先跳 1 步，从位置 0 到位置 1，然后跳 3 步到达最后一个位置。
输入：nums = [3, 2, 1, 0, 4]
输出：false
解释：无论如何你都无法越过索引 3 处的 0，因此无法到达最后一个位置。

2. 跳跃游戏 I 的解题思路

该问题可以通过贪心算法或动态规划来求解。我们尝试寻找每一步可以跳到的最远距离，以确定是否能够到达数组末尾。

贪心算法思路：

定义一个变量 farthest，表示能够跳到的最远位置。
遍历数组中的每个元素，逐步更新 farthest，即每次都更新当前位置能够跳到的最远位置。
如果在遍历过程中，发现当前位置已经超过 farthest，则无法到达末尾，返回 false。
如果遍历到数组末尾或更远，说明可以到达末尾，返回 true。

3. 贪心算法的实现

下面是跳跃游戏 I 的贪心算法 Java 实现：

public class JumpGame {
    
    public boolean canJump(int[] nums) {
        int farthest = 0;  // 表示能够跳到的最远距离

        // 遍历数组
        for (int i = 0; i < nums.length; i++) {
            // 如果当前位置已经超过了之前能够跳到的最远距离，则返回 false
            if (i > farthest) {
                return false;
            }
            // 更新能够跳到的最远距离
            farthest = Math.max(farthest, i + nums[i]);
        }

        return true;  // 能够到达最后一个位置
    }

    public static void main(String[] args) {
        JumpGame game = new JumpGame();
        int[] nums = {2, 3, 1, 1, 4};
        System.out.println("Can jump to the end: " + game.canJump(nums));  // 输出 true

        int[] nums2 = {3, 2, 1, 0, 4};
        System.out.println("Can jump to the end: " + game.canJump(nums2));  // 输出 false
    }
}

4. 代码详解

4.1 输入与输出

输入：一个非负整数数组 nums[]，每个元素表示在该位置最多可以跳跃的步数。
输出：返回 true 或 false，表示是否可以跳跃到达数组的最后一个位置。

4.2 关键步骤

初始化：定义一个变量 farthest，用于记录当前可以跳到的最远位置，初始值为 0。
遍历数组：从第一个元素开始逐步更新最远可到达的位置。
- 每次遍历时，判断当前位置 i 是否可以被访问。如果当前位置已经超出 farthest，则说明无法到达该位置，返回 false。
- 每次更新 farthest 为当前位置 i 能够跳到的最远位置 i + nums[i]。
判断结果：如果遍历完数组，farthest 大于或等于数组最后一个位置的索引，则返回 true。

4.3 时间复杂度和空间复杂度

时间复杂度：O(n)，我们只需要遍历一次数组。
空间复杂度：O(1)，只使用了常量级的额外空间。

5. 跳跃游戏 II 问题描述

跳跃游戏 II 是跳跃游戏的升级版，要求找出到达数组末尾的最小跳跃次数。

示例：

输入：nums = [2, 3, 1, 1, 4]
输出：2
解释：我们可以先跳 1 步到达位置 1，然后再跳 3 步到达最后一个位置。

6. 跳跃游戏 II 的解题思路

为了在最少跳跃次数下到达数组末尾，我们需要跟踪每次跳跃的最远位置，同时确定何时进行下一次跳跃。

贪心算法思路：

定义变量 jumps 记录跳跃次数，end 记录当前跳跃的边界，farthest 记录能够跳到的最远位置。
遍历数组，如果当前索引超过了 end，则进行一次跳跃，跳跃的边界更新为 farthest，同时增加跳跃次数。
重复该过程直到遍历完整个数组。

7. 贪心算法的实现

下面是跳跃游戏 II 的贪心算法 Java 实现：

public class JumpGameII {

    public int jump(int[] nums) {
        int jumps = 0;      // 跳跃次数
        int farthest = 0;   // 能够跳到的最远距离
        int end = 0;        // 当前跳跃的边界

        for (int i = 0; i < nums.length - 1; i++) {
            // 更新能够跳到的最远距离
            farthest = Math.max(farthest, i + nums[i]);

            // 当到达当前跳跃边界时，进行跳跃
            if (i == end) {
                jumps++;
                end = farthest;  // 更新跳跃的边界

                // 如果当前边界已经到达或超过最后一个元素，结束循环
                if (end >= nums.length - 1) {
                    break;
                }
            }
        }

        return jumps;  // 返回跳跃次数
    }

    public static void main(String[] args) {
        JumpGameII game = new JumpGameII();
        int[] nums = {2, 3, 1, 1, 4};
        System.out.println("Minimum jumps: " + game.jump(nums));  // 输出 2
    }
}

8. 代码详解

8.1 输入与输出

输入：一个非负整数数组 nums[]，每个元素表示在该位置最多可以跳跃的步数。
输出：返回到达数组末尾的最小跳跃次数。

8.2 关键步骤

初始化：定义变量 jumps 表示跳跃次数，farthest 表示可以跳到的最远位置，end 表示当前跳跃的边界。
遍历数组：每次更新最远可跳到的位置 farthest，如果当前索引达到边界 end，说明需要进行一次跳跃，跳跃次数 jumps 加 1，更新边界 end 为 farthest。
判断结束：当边界达到或超过数组的最后一个位置时，结束循环并返回跳跃次数。