【LeetCode刷题】跳跃游戏Ⅱ

给定一个长度为 n 的 0 索引 整数数组 nums。初始位置在下标 0。

每个元素 nums[i] 表示从索引 i 向后跳转的最大长度。换句话说，如果你在索引 i 处，你可以跳转到任意 (i + j) 处：

0 <= j <= nums[i] 且
i + j < n

返回到达 n - 1 的最小跳跃次数。测试用例保证可以到达 n - 1。

示例 1:

复制代码

输入: nums = [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
     从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

示例 2:

复制代码

输入: nums = [2,3,0,1,4]
输出: 2

提示:

1 <= nums.length <=
0 <= nums[i] <= 1000
题目保证可以到达 n - 1

算法思路

核心是贪心策略：每次在当前跳跃的范围内，找到能到达的最远位置，到达当前范围边界时，进行一次跳跃并更新边界。

初始化变量 ：
- step：记录跳跃次数；
- current_end：当前跳跃能覆盖的最远下标；
- next_farthest：下一次跳跃能覆盖的最远下标。
遍历数组 ：
- 遍历过程中持续更新next_farthest（即当前位置能跳到的最远点）；
- 当遍历到current_end（当前跳跃的边界）时，说明需要进行一次跳跃，此时：
  - 跳跃次数step加 1；
  - 将current_end更新为next_farthest（下一次跳跃的边界）；
  - 若新边界已覆盖最后一个元素，提前结束遍历（优化效率）。

示例验证

以示例 1 nums = [2,3,1,1,4] 为例：

初始：step=0，current_end=0，next_farthest=0；
遍历i=0：next_farthest=0+2=2，i==current_end → step=1，current_end=2；
遍历i=1：next_farthest=max(2,1+3=4)；
遍历i=2：i==current_end → step=2，current_end=4（已覆盖最后一个元素，跳出循环）；
返回step=2，与示例结果一致。

Python代码：

python 复制代码

from typing import List


class Solution:
    def jump(self, nums: List[int]) -> int:
        """
        计算到达数组最后一个位置的最少跳跃次数
        :param nums: 非负整数数组，nums[i]表示在位置i可以跳跃的最大长度
        :return: 最少跳跃次数
        """
        n = len(nums)
        # 边界条件：数组长度为1，已在终点，无需跳跃
        if n == 1:
            return 0

        step = 0  # 记录跳跃次数
        current_end = 0  # 当前跳跃范围的右边界（到达该边界时必须跳一次）
        next_farthest = 0  # 遍历过程中能到达的最远位置

        # 遍历到倒数第二个元素即可（最后一个元素无需跳跃）
        for i in range(n - 1):
            # 不断更新「下一步能到达的最远位置」
            next_farthest = max(next_farthest, i + nums[i])

            # 到达当前跳跃范围的边界，必须进行一次跳跃
            if i == current_end:
                step += 1  # 跳跃次数+1
                current_end = next_farthest  # 更新下一次跳跃的边界

                # 提前终止：若当前边界已覆盖最后一个元素，无需继续遍历
                if current_end >= n - 1:
                    break

        return step


# 测试用例（可直接运行验证）
if __name__ == "__main__":
    solution = Solution()

    # 示例1：预期输出 2
    nums1 = [2, 3, 1, 1, 4]
    print(f"测试用例1: nums = {nums1} → 最少跳跃次数: {solution.jump(nums1)}")

    # 示例2：预期输出 2
    nums2 = [2, 3, 0, 1, 4]
    print(f"测试用例2: nums = {nums2} → 最少跳跃次数: {solution.jump(nums2)}")

    # 边界用例1：数组长度为1 → 预期输出 0
    nums3 = [1]
    print(f"测试用例3: nums = {nums3} → 最少跳跃次数: {solution.jump(nums3)}")

    # 边界用例2：逐格跳跃 → 预期输出 3
    nums4 = [1, 1, 1, 1]
    print(f"测试用例4: nums = {nums4} → 最少跳跃次数: {solution.jump(nums4)}")

    # 自定义输入
    try:
        input_str = input("\n请输入自定义数组（以逗号分隔，如2,3,1,1,4）：")
        nums_custom = [int(num) for num in input_str.split(",")]
        print(f"自定义用例: nums = {nums_custom} → 最少跳跃次数: {solution.jump(nums_custom)}")
    except ValueError:
        print("输入格式错误，请输入以逗号分隔的非负整数！")

LeetCode提交代码：

python 复制代码

class Solution:
    from typing import List
    def jump(self, nums: List[int]) -> int:
        n = len(nums)
        if n == 1:
            return 0  # 数组长度为1时无需跳跃
        
        step = 0  # 跳跃次数
        current_end = 0  # 当前跳跃能到达的最远边界
        next_farthest = 0  # 下一次跳跃能到达的最远位置
        
        # 遍历到倒数第二个元素即可（最后一个元素无需跳跃）
        for i in range(n - 1):
            # 更新下一次能到达的最远位置
            next_farthest = max(next_farthest, i + nums[i])
            
            # 到达当前跳跃的边界，需要进行下一次跳跃
            if i == current_end:
                step += 1
                current_end = next_farthest  # 更新跳跃边界
                # 若当前边界已覆盖最后一个元素，提前结束
                if current_end >= n - 1:
                    break
        
        return step

程序运行截图展示：

总结

本文介绍了一种基于贪心策略的算法，用于求解跳跃游戏问题。给定一个非负整数数组，每个元素表示在该位置可跳跃的最大长度，算法计算从数组起始位置到达末尾的最小跳跃次数。通过维护当前跳跃边界和下一次跳跃的最远可达位置，在遍历数组时动态更新这两个变量，当到达当前边界时增加跳跃次数并更新边界。该算法时间复杂度为O(n)，空间复杂度为O(1)，能高效解决问题。文章提供了Python实现代码、测试用例及详细解释，验证了算法的正确性。