代码随想录第32天 | 贪心算法 part02

代码随想录算法训练营第32天 | 贪心算法 part02

● 122.买卖股票的最佳时机II
● 55. 跳跃游戏
● 45.跳跃游戏II

题目一 122.买卖股票的最佳时机II

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
示例 1:

• 输入: [7,1,5,3,6,4]
• 输出: 7
• 解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4。随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

本题本质上是选取数组中差值最大的两个数(还是按顺序来的)，
也就是nums[i+n] - nums[i]的最大值。
但是交易不只一次，也就是计算多次差值的和，因此涉及到 多次数 小差值 和 少次数 大差值 的取舍。

如果想到其实最终利润是可以分解的，那么本题就很容易了！

也就是nums[i+n] - nums[i] 分解为(nums[i+n] - nums[i + n-1 ]) + (nums[i + n-1 ] + )… + (nums[i+1] - nums[i])

假如第 0 天买入，第 3 天卖出，那么利润为：prices[3] - prices[0]。
相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])。
此时就是把利润分解为每天为单位的维度，而不是从 0 天到第 3 天整体去考虑！

因此本题需要得到一个每天相邻差值的数组，然后把所有的正值加起来，(负值不要)，就能得到最终结果。
第一天收益为0，没有利润。
![[Pasted image 20231211205355.png|400]]

public int maxProfit(int[] prices) 
{
	int len = prices.length;
	int ans = 0;
	for(int i=1; i<len; i++)
	{
		ans += Math.max(prices[i] - prices[i-1], 0);
	}
	return ans;
}

• 时间复杂度：O(n)
• 空间复杂度：O(1)

题目二 55. 跳跃游戏

给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个位置。
示例 1:

• 输入: [2,3,1,1,4]
• 输出: true
• 解释: 我们可以先跳 1 步，从位置 0(最大步长为2) 到达 位置 1, 然后再从位置 1 (最大步长为3)跳 3 步到达最后一个位置。

局部最优：每次跳都选最大步长
整体最优：跳到终点

那么这个问题就转化为跳跃覆盖范围究竟可不可以覆盖到终点！
每次移动取最大跳跃步数（得到最大的覆盖范围），每移动一个单位，就更新最大覆盖范围。
贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点。

注意：i 每次移动只能在 cover 的范围内移动，不能逾越。

每移动一个元素，cover 得到该元素数值（新的覆盖范围）的补充，让 i 继续移动下去。
而 cover 每次只取 max(该元素数值补充后的范围, cover 本身范围)。
因为是读取到某个元素才知道接下来的范围，因此是 i + nums[i]。i为已经在数组上开拓的范围，nums[i]为得到的拓宽范围。
如果 cover 大于等于了终点下标，直接 return true 就可以了。

public boolean canJump(int[] nums) 
{
	int len = nums.length;
	if(len == 1)// 只有一个元素，就是能达到
		return true;
	int cover = 0;
	for(int i=0; i<=cover; i++)
	{
		cover = Math.max(i + nums[i], cover);
		if(cover >= len - 1)
			return true;
	}
	return false;
}

时间复杂度: O(n)
空间复杂度: O(1)

题目三 45.跳跃游戏II

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

• 输入: [2,3,1,1,4]
• 输出: 2
• 解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
  说明: 假设你总是可以到达数组的最后一个位置。

本题要的是最短步数，与上题差异还是不小。首先题目明确了我们能走到最后的位置，只需对路径进行优化。
贪心的思路，
局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。
整体最优：一步尽可能多走，从而达到最少步数。

但是不能真的每次都是最大，因为可能涉及到步长溢出。

所以真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最少步数！
每次需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖。

如果移动下标达到了当前这一步的最大覆盖最远距离了，还没有到终点的话，那么就必须再走一步来增加覆盖范围，直到覆盖范围覆盖了终点。

长度为1的时候，开始就已经在最后一个元素处，因此返回0.
更新范围时让next开拓(与上题类似)，
而只在需要的情况下，让结果加一(多走一步)，然后将next的值赋给cur.
记住本题步数很宝贵，因此只在必要的时候加一。

public int jump(int[] nums) 
{
	int len = nums.length;
	if(len == 1)
		return 0;
	int ans = 0;
	int curcover = 0, nextcover = 0;
	for(int i=0; i<len; i++)
	{
		nextcover = Math.max(i + nums[i], nextcover);
		if(i == curcover)// 遇到当前覆盖最远距离下标,i追上cur
		{
			ans++;//不得不走下一步，结果加一
			curcover = nextcover;//更新，再让i追赶cur
			if(nextcover >= len - 1) 
				// 当前覆盖最远距到达集合终点，不用做ans++操作了，直接结束
				break;
		}
	}
	return ans;
}

• 时间复杂度: O(n)
• 空间复杂度: O(1)

第二种方法：上面在能覆盖到终点的时候进行了特殊判定退出循环，现在进行改良以去掉判定。
达到这样的效果，只要让移动下标，最大只能移动到nums.size - 2 的地方就可以了。
我们需要考虑走到最后一步的情况。
要么在i和范围都到达nums.size-2 时，还得再加，额外补上最后一步；
要么最大范围不在这个位置，那么直接能推断出这一次能走到终点。

代码如下，进行了一些简化，注意i是小于nums.size() - 1，这是重点。

public int jump(int[] nums) 
{
	int curDistance = 0;    // 当前覆盖的最远距离下标
	int ans = 0;            // 记录走的最大步数
	int nextDistance = 0;   // 下一步覆盖的最远距离下标
	for (int i = 0; i < nums.size() - 1; i++) 
	{ // 注意这里是小于nums.size() - 1，这是关键所在
		nextDistance = max(nums[i] + i, nextDistance); // 更新下一步覆盖的最远距离下标
		if (i == curDistance) 
		{                 // 遇到当前覆盖的最远距离下标
			curDistance = nextDistance;         // 更新当前覆盖的最远距离下标
			ans++;
		}
	}
	return ans;
}