@TOC
前言
代码随想录算法训练营day32
一、Leetcode 122.买卖股票的最佳时机II
1.题目
给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。
示例 1：
输入：prices = [7,1,5,3,6,4] 输出：7 解释：在第 2 天(股票价格 = 1)的时候买入，在第 3 天(股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。 随后，在第 4 天(股票价格 = 3)的时候买入，在第 5 天(股票价格 = 6)的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3 。 总利润为 4 + 3 = 7 。
示例 2：
输入：prices = [1,2,3,4,5] 输出：4 解释：在第 1 天(股票价格 = 1)的时候买入，在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。 总利润为 4 。
示例 3：
输入：prices = [7,6,4,3,1] 输出：0 解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。
提示：
1 <= prices.length <= 3 * 104
0 <= prices[i] <= 104来源：力扣(LeetCode) 链接：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii
2.解题思路
方法一：动态规划
考虑到「不能同时参与多笔交易」，因此每天交易结束后只可能存在手里有一支股票或者没有股票的状态。
定义状态 dp[i][0]dp[i][0] 表示第 ii 天交易完后手里没有股票的最大利润，dp[i][1]dp[i][1] 表示第 ii 天交易完后手里持有一支股票的最大利润(ii 从 00 开始)。
考虑 dp[i][0]dp[i][0] 的转移方程，如果这一天交易完后手里没有股票，那么可能的转移状态为前一天已经没有股票，即 dp[i−1][0]dp[i−1][0]，或者前一天结束的时候手里持有一支股票，即 dp[i−1][1]dp[i−1][1]，这时候我们要将其卖出，并获得 prices[i]prices[i] 的收益。因此为了收益最大化，我们列出如下的转移方程：
dp[i][0]=max{dp[i−1][0],dp[i−1][1]+prices[i]}dp[i][0]=max{dp[i−1][0],dp[i−1][1]+prices[i]}
再来考虑 dp[i][1]dp[i][1]，按照同样的方式考虑转移状态，那么可能的转移状态为前一天已经持有一支股票，即 dp[i−1][1]dp[i−1][1]，或者前一天结束时还没有股票，即 dp[i−1][0]dp[i−1][0]，这时候我们要将其买入，并减少 prices[i]prices[i] 的收益。可以列出如下的转移方程：
dp[i][1]=max{dp[i−1][1],dp[i−1][0]−prices[i]}dp[i][1]=max{dp[i−1][1],dp[i−1][0]−prices[i]}
对于初始状态，根据状态定义我们可以知道第 00 天交易结束的时候 dp[0][0]=0dp[0][0]=0，dp[0][1]=−prices[0]dp[0][1]=−prices[0]。
因此，我们只要从前往后依次计算状态即可。由于全部交易结束后，持有股票的收益一定低于不持有股票的收益，因此这时候 dp[n−1][0]dp[n−1][0] 的收益必然是大于 dp[n−1][1]dp[n−1][1] 的，最后的答案即为 dp[n−1][0]dp[n−1][0]。
3.代码实现
```java class Solution { public int maxProfit(int[] prices) { int n = prices.length; int[][] dp = new int[n][2]; dp[0][0] = 0; dp[0][1] = -prices[0]; for (int i = 1; i < n; ++i) { dp[i][0] = Math.max(dp[i - 1][0], dp[i - 1][1] + prices[i]); dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]); } return dp[n - 1][0]; } }
```
二、Leetcode 55. 跳跃游戏
1.题目
给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。
示例 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 <= 3 * 104
0 <= nums[i] <= 105来源：力扣(LeetCode) 链接：https://leetcode.cn/problems/jump-game
2.解题思路
方法一：贪心
我们可以用贪心的方法解决这个问题。
设想一下，对于数组中的任意一个位置 yy，我们如何判断它是否可以到达？根据题目的描述，只要存在一个位置 xx，它本身可以到达，并且它跳跃的最大长度为 x+nums[x]x+nums[x]，这个值大于等于 yy，即 x+nums[x]≥yx+nums[x]≥y，那么位置 yy 也可以到达。
换句话说，对于每一个可以到达的位置 xx，它使得 x+1,x+2,⋯ ,x+nums[x]x+1,x+2,⋯,x+nums[x] 这些连续的位置都可以到达。
这样以来，我们依次遍历数组中的每一个位置，并实时维护 最远可以到达的位置。对于当前遍历到的位置 xx，如果它在 最远可以到达的位置 的范围内，那么我们就可以从起点通过若干次跳跃到达该位置，因此我们可以用 x+nums[x]x+nums[x] 更新 最远可以到达的位置。
在遍历的过程中，如果 最远可以到达的位置 大于等于数组中的最后一个位置，那就说明最后一个位置可达，我们就可以直接返回 True 作为答案。反之，如果在遍历结束后，最后一个位置仍然不可达，我们就返回 False 作为答案。
以题目中的示例一
[2, 3, 1, 1, 4]
为例：
我们一开始在位置 00，可以跳跃的最大长度为 22，因此最远可以到达的位置被更新为 22；
我们遍历到位置 11，由于 1≤21≤2，因此位置 11 可达。我们用 11 加上它可以跳跃的最大长度 33，将最远可以到达的位置更新为 44。由于 44 大于等于最后一个位置 44，因此我们直接返回 True。我们再来看看题目中的示例二
[3, 2, 1, 0, 4]
我们一开始在位置 00，可以跳跃的最大长度为 33，因此最远可以到达的位置被更新为 33；
我们遍历到位置 11，由于 1≤31≤3，因此位置 11 可达，加上它可以跳跃的最大长度 22 得到 33，没有超过最远可以到达的位置；
位置 22、位置 33 同理，最远可以到达的位置不会被更新；
我们遍历到位置 44，由于 4>34>3，因此位置 44 不可达，我们也就不考虑它可以跳跃的最大长度了。在遍历完成之后，位置 44 仍然不可达，因此我们返回 False。
3.代码实现
```java public class Solution { public boolean canJump(int[] nums) { int n = nums.length; int rightmost = 0; for (int i = 0; i < n; ++i) { if (i <= rightmost) { rightmost = Math.max(rightmost, i + nums[i]); if (rightmost >= n - 1) { return true; } } } return false; } }
```
三、Leetcode 45.跳跃游戏II
1.题目
给定一个长度为 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 <= nums[i] <= 1000
题目保证可以到达 nums[n-1]来源：力扣(LeetCode) 链接：https://leetcode.cn/problems/jump-game-ii
2.解题思路
方法一：反向查找出发位置
我们的目标是到达数组的最后一个位置，因此我们可以考虑最后一步跳跃前所在的位置，该位置通过跳跃能够到达最后一个位置。
如果有多个位置通过跳跃都能够到达最后一个位置，那么我们应该如何进行选择呢？直观上来看，我们可以「贪心」地选择距离最后一个位置最远的那个位置，也就是对应下标最小的那个位置。因此，我们可以从左到右遍历数组，选择第一个满足要求的位置。
找到最后一步跳跃前所在的位置之后，我们继续贪心地寻找倒数第二步跳跃前所在的位置，以此类推，直到找到数组的开始位置。
使用这种方法编写的 C++ 和 Python 代码会超出时间限制，因此我们只给出 Java 和 Go 代码。
3.代码实现
```java class Solution { public int jump(int[] nums) { int position = nums.length - 1; int steps = 0; while (position > 0) { for (int i = 0; i < position; i++) { if (i + nums[i] >= position) { position = i; steps++; break; } } } return steps; } }
```