Leetcode 跳跃游戏 II （贪心算法）

原创

于 2025-04-09 22:00:19 发布 · 800 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #数据结构

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

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

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

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[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 <= 104
0 <= num

最低0.47元/天解锁文章

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

basketball616

关注关注

13
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

45. 跳跃游戏 II（力扣LeetCode）

m0_73841621的博客

03-13

1371

如果移动下标达到了当前这一步的最大覆盖最远距离了，还没有到终点的话，那么就必须再走一步来增加覆盖范围，直到覆盖范围覆盖了终点。贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。从图中可以看出来，就是移动下标达到了当前覆盖的最远距离下标时，步数就要加一，来增加覆盖距离。最后的步数就是最少步数。思路虽然是这样，但在写代码的时候还不能真的能跳多远就跳多远，那样就不知道下一步最远能跳到哪里了。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

LeetCode 55 & 45：跳跃游戏与跳跃游戏 II - 贪心算法详解

最新发布

weixin_44435110的博客

05-29

800

跳跃游戏系列是LeetCode中经典的贪心算法问题，考察对数组遍历和最优策略的理解。本文将详细解析55题（跳跃游戏）和45题（跳跃游戏 II）的解决方案，通过图解和Java实现帮助读者掌握贪心算法的应用。

参与评论您还未登录，请先登录后发表或查看评论

【LeetCode】跳跃游戏II

weixin_59546710的博客

09-02

258

【代码】【LeetCode】跳跃游戏II。

45. 跳跃游戏 II （贪心）

hpu风之旅

07-09

592

力扣算法：45. 跳跃游戏 II

【力扣】跳跃游戏II-动态规划（C++）

sacurua的博客

01-24

501

首先，数组所有元素统统将对应的值+对应的下标，即nums[i]+i。然后通过两层循环，内层循环从下标最小往最大方向，查找能到达相对终点的最小下标元素，然后将其当做新的相对终点，继续寻找到这个点的最小下标元素。在编写代码过程中遇到，初始数组为【0】的情况，此时步数应该为0，但是根据以上算法，步数为1。跳到最后一个位置的最小跳跃数是2。从下标为 0 跳到下标为 1 的位置，跳1步，然后跳3步到达数组的最后一个位置。外层循环作用为更新相对终点，以及判定是否为从下标0开始，如果是，则退出循环，计算结束。

leetcode-45. 跳跃游戏 II

sinat_41679123的博客

08-06

416

leetcode - 45

LeetCode刷题日记之贪心算法（二）

粥的博客

10-18

1540

在上一篇贪心算法的学习中，我们探讨了贪心算法的基本思路和逻辑框架。在这篇文章中，我将继续分享几道经典的LeetCode贪心算法题，并探讨其背后的解题思路和技巧。希望通过这些题目的实践，能加深我对贪心算法的理解，也为同样在刷题的小伙伴提供更多思考和启发✍✍✍

LeetCode045——跳跃游戏II

清风阁

09-19

2937

我的LeetCode代码仓：https://github.com/617076674/LeetCode 原题链接：https://leetcode-cn.com/problems/jump-game-ii/description/ 题目描述：知识点：贪心算法 思路一：回溯法（在LeetCode中提交会超时）回溯法的思想很简单，寻找到所有能到达数组的最后一个位置的可能路径，计算其最...

力扣（leetcode）45、跳跃游戏2超详细题解，经典贪心算法

qq_46248151的博客

03-30

1115

所以在范围区间内部某点（记为a）即使有跳的更远的地方，则maxPosition也会保留下来，我们就可以认作上次跳跃是从start-a (含有一个step)，a-maxPosition，因为start可以跳到最远的end，也就可以跳一步跳到a。的范围内，我们维护一个maxPosition，表示能跳到的最远距离，每次遍历maxPosition = Math.max(maxPosition, i + nums[i]);下一次跳跃的最远距离在哪？这样每到达一个边界的时候，我们就结束了当前跳跃，而进入到下一次跳跃。

（leetcode）跳跃游戏Ⅱ

qq_41087751的博客

10-15

1108

递归算法与非递归贪心算法的实现

leetcode：45. 跳跃游戏 II

OceanStar的博客

05-23

1844

题目来源 leetcode：jump-game-ii 题目描述 class Solution { public: int jump(vector<int>& nums) { } }; 题目解析从数组的第 0 个位置开始跳，跳的距离小于等于数组上对应的数。求出跳到最后个位置需要的最短步数。贪心思路：别想那么多，就挨着跳吧如果某一个起跳点的格式可以跳跃的距离是3，那么表示后面3个格子都可以作为起跳点如果从这个起跳点叫做第1次跳跃，那么从后面3个格子起

LeetCode 45. 跳跃游戏 II【贪心算法】

实用技术干货分享⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄对您有用的话请点个关注吧~

03-23

390

每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。输入: nums = [2,3,1,1,4]解释: 跳到最后一个位置的最小跳跃数是 2。输入: nums = [2,3,0,1,4]题目保证可以到达 nums[n-1]

LeetCode 45 跳跃游戏 II（Java）

qq_43623492的博客

01-22

2974

题目：给你一个非负整数数组 nums ，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。你的目标是使用最少的跳跃次数到达数组的最后一个位置。假设你总是可以到达数组的最后一个位置。示例1：输入: nums = [2,3,1,1,4] 输出: 2 解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。示例2：输入: nums = [2,3,0,1,4] 输出: 2 提示：

LeetCode 55. 跳跃游戏 & 45. 跳跃游戏II——贪心算法

gulugulu1103的博客

11-26

1903

给你一个非负整数数组nums，你最初位于数组的。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个下标，如果可以，返回true；否则，返回false。**输入：**nums = [2,3,1,1,4]**输出：**true**解释：**可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。**输入：**nums = [3,2,1,0,4]**输出：**false**解释：**无论怎样，总会到达下标为 3 的位置。

leetcode(力扣) 45. 跳跃游戏 II （贪心算法）

深度不学习！！的博客

12-12

3374

实际上简单来讲，就是不断循环数组，从遍历下标i到end，在此过程中找出下次跳跃的最远距离，如果遍历下标到达本次的边界end了，则说明本次遍历已经完事了，已经达到本次的最远距离了，步数+1.然后让刚才找到的下次跳跃最远距离变成本次的，然后重复操作就行了。这块可以想象一下，我们操作的时候是当 i == end时步数+1，也就是说当前下标i已经走到了边界了，该下一步了，所以直接让步数+1了。那么每次跳跃的时候，在可跳跃范围内选择下一次跳跃的起点，使得本次跳跃+下次跳跃可以达到的距离最远。

LeetCode 45. 跳跃游戏 II

m0_51691373的博客

01-09

715

也不同，所以每一个点走一步所能到达最远的点都是不一样的。并且我们保证了走两步点组中的所有点，它们都是最少的步数，它们之中都不存在，明明一步能到的，我们给他更新成了两步（这个之前也分析了），同样也不存在的是，这个走两步点组的右边界的下一个点一定是需要走三步才能到的，也就是说我们把走两步点组的下标范围，也是更新成了最大的范围，不能再大了。这也是贪心的思想，每一个当前最优的状态的，是从上一个最优的状态更新过来的，上一个是最优状态，再走一步到达的这个点，肯定也是最优状态，这也就是这题动态规划+贪心的魅力所在吧。

leetcode贪心算法-跳跃游戏II

nth2000的博客

11-13

3027

IDEA 动态规划（从后向前）时间复杂度O(n2)O(n^2)O(n2) class Solution { public int jump(int[] nums) { nums[nums.length - 1] = 0; for(int i = nums.length - 2;i>=0;i--) { int temp = nums[i]; nums[i] = Integer.MAX_VALU.

45. 跳跃游戏 II【力扣(LeetCode) 】

yyh520025的博客

07-29

633

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说，如果你在 nums[i] 处，你可以跳转到任意 nums[i + j] 处。返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

算法（贪心）：跳跃游戏 II

o_ni_jiang的博客

07-22

215

给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。你的目标是使用最少的跳跃次数到达数组的最后一个位置。

leetcode热门100题贪心算法python

03-23

### LeetCode Top 100 贪心算法题目 Python 实现 贪心算法是一种通过局部最优解来达到全局最优解的方法，在许多实际问题中有广泛应用。以下是基于常见需求整理的一系列与贪心算法相关的热门问题及其对应的 Python 解法。 #### 1. **分发饼干 (Assign Cookies)** 给定饥饿度不同的孩子和大小不一的饼干，分配饼干使尽可能多的孩子感到满足[^1]。 ```python def findContentChildren(g, s): g.sort() s.sort() i, j = 0, 0 while i < len(g) and j < len(s): if s[j] >= g[i]: i += 1 j += 1 return i ``` --- #### 2. **跳跃游戏 (Jump Game II)** 计算从数组的第一个位置到达最后一个位置所需的最少步数[^4]。 ```python def jump(nums): n = len(nums) max_pos, end, steps = 0, 0, 0 for i in range(n - 1): max_pos = max(max_pos, i + nums[i]) if i == end: end = max_pos steps += 1 return steps ``` --- #### 3. **区间调度 (Non-overlapping Intervals)** 移除最少数目的区间使其互不重叠[^2]。 ```python def eraseOverlapIntervals(intervals): if not intervals: return 0 intervals.sort(key=lambda x: x[1]) # 按结束时间排序 count = 1 end = intervals[0][1] for interval in intervals[1:]: if interval[0] >= end: count += 1 end = interval[1] return len(intervals) - count ``` --- #### 4. **拼车问题 (Car Pooling)** 判断一辆容量固定的汽车能否接送所有乘客而不超载。 ```python def carPooling(trips, capacity): events = [] for num, start, end in trips: events.append((start, num)) events.append((end, -num)) events.sort() # 时间顺序排列 current_load = 0 for _, passengers in events: current_load += passengers if current_load > capacity: return False return True ``` --- #### 5. **最大利润 (Maximum Profit in Job Scheduling)** 安排工作以获得最大的总利润。 ```python def jobScheduling(startTime, endTime, profit): jobs = sorted(zip(endTime, startTime, profit)) # 按结束时间排序 dp = [jobs[0][2]] for i in range(1, len(jobs)): curr_profit = jobs[i][2] l = bisect_right([job[0] for job in jobs], jobs[i][1]) - 1 if l != -1: curr_profit += dp[l] dp.append(max(curr_profit, dp[-1])) return dp[-1] ``` --- #### 工具推荐对于上述解决方案的实际编写与调试，建议使用高效的开发工具如 PyCharm 或 VSCode 来提升效率[^3]。 --- ### 总结以上展示了部分经典贪心算法问题的 Python 实现方案。每种方法均经过优化设计，能够有效解决特定场景下的复杂问题。