目录
LeetCode122. 买卖股票的最佳时机
LeetCode122. 链接： 122. 买卖股票的最佳时机 II - 力扣（LeetCode）
1. 思路
本题首先要清楚两点：
- 只有一只股票！
- 当前只有买股票或者卖股票的操作
想获得利润至少要两天为一个交易单元，这道题目可能我们只会想，选一个低的买入，在选个高的卖，在选一个低的买入.....循环反复。
如果想到其实最终利润是可以分解的，那么本题就很容易了！
如何分解呢？
假如第0天买入，第3天卖出，那么利润为：prices[3] - prices[0]。相当于(prices[3] - prices[2]) + (prices[2] - prices[1]) + (prices[1] - prices[0])；
此时就是把利润分解为每天为单位的维度，而不是从0天到第3天整体去考虑！
那么根据prices可以得到每天的利润序列：(prices[i] - prices[i - 1]).....(prices[1] - prices[0])；
注意： 一些同学陷入：第一天怎么就没有利润呢，第一天到底算不算的困惑中。第一天当然没有利润，至少要第二天才会有利润，所以利润的序列比股票序列少一天！
贪心算法：我们需要收集每天的正利润就可以
从图中可以发现，其实我们需要收集每天的正利润就可以，收集正利润的区间，就是股票买卖的区间，而我们只需要关注最终利润，不需要记录区间。
那么只收集正利润就是贪心所贪的地方！
局部最优：收集每天的正利润，全局最优：求得最大利润。
局部最优可以推出全局最优，找不出反例，试一试贪心！
2. 代码实现
在代码实现中，其实并不需要真的创建一个“每天的利润”的数组，只需要在遍历原来的数组上，计算出从第二天开始的利润，并且如果是正数的话就加到result变量中去即可；具体代码实现如下：
# 贪心算法
# time:O(N);space:O(1)
class Solution(object):
def maxProfit(self, prices):
"""
:type prices: List[int]
:rtype: int
"""
result = 0
# 从第二天开始，才有利润
for i in range(1,len(prices)):
# 如果利润小于0，不统计
# 利润大于0，才统计
result += max(0,prices[i]-prices[i-1])
return result
3. 复杂度分析
时间复杂度：O(N）；
需要遍历prices数组一次；
空间复杂度：O(1）
只有常数个变量来记录；
4. 思考与收获
-
股票问题其实是一个系列的，属于动态规划的范畴，因为目前在讲解贪心系列，所以股票问题会在之后的动态规划系列中详细讲解；
-
可以看出有时候，贪心往往比动态规划更巧妙，更好用，所以别小看了贪心算法；
-
本题中理解利润拆分是关键点！ 不要整块的去看，而是把整体利润拆为每天的利润；一旦想到这里了，很自然就会想到贪心了，即：只收集每天的正利润，最后稳稳的就是最大利润了；
-
（二刷再看）动态规划做法:
class Solution: def maxProfit(self, prices: List[int]) -> int: length = len(prices) dp = [[0] * 2 for _ in range(length)] dp[0][0] = -prices[0] dp[0][1] = 0 for i in range(1, length): dp[i][0] = max(dp[i-1][0], dp[i-1][1] - prices[i]) #注意这里是和121. 买卖股票的最佳时机唯一不同的地方 dp[i][1] = max(dp[i-1][1], dp[i-1][0] + prices[i]) return dp[-1][1]- 时间复杂度：O(n)
- 空间复杂度：O(n)
Reference：代码随想录 (programmercarl.com)
本题学习时间：20分钟。
LeetCode55. 跳跃游戏
LeetCode55. 链接：55. 跳跃游戏 - 力扣（LeetCode）
1. 思路
把问题转换的更简单一点？
刚看到本题一开始可能想：当前位置元素如果是3，我究竟是跳一步呢，还是两步呢，还是三步呢，究竟跳几步才是最优呢？其实跳几步无所谓，关键在于可跳的覆盖范围！
不一定非要明确一次究竟跳几步，每次取最大的跳跃步数，这个就是可以跳跃的覆盖范围。这个范围内，别管是怎么跳的，反正一定可以跳过来。那么这个问题就转化为跳跃覆盖范围究竟可不可以覆盖到终点！
贪心算法怎么贪心呢？
每次移动取最大跳跃步数（得到最大的覆盖范围），每移动一个单位，就更新最大覆盖范围。
贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点。
局部最优推出全局最优，找不出反例，试试贪心！如图：
具体代码实现思路
i每次移动只能在cover的范围内移动，每移动一个元素，cover得到该元素数值（新的覆盖范围）的补充，让i继续移动下去；
而cover每次只取 max(该元素数值补充后的范围, cover本身范围)，如果cover大于等于了终点下标，直接return true就可以了。
2. 代码实现
# 贪心解法
# time:O(N);space:O(1)
class Solution(object):
def canJump(self, nums):
"""
:type nums: List[int]
:rtype: bool
"""
# 只有一个元素，就是能达到
if len(nums) == 1: return True
cur = 0
cover = 0
# python不支持动态修改for循环中变量,使用while循环代替
# 注意这里是小于等于cover
while cur <= cover:
cover = max(cover, nums[cur]+cur)
# 说明可以覆盖到终点了
if cover >= len(nums)-1:
return True
cur += 1
return False
3. 复杂度分析
时间复杂度：O(N）；
需要遍历数组一次；
空间复杂度：O(1）
只有常数个变量来记录；
4. 思考与收获
-
我自己写的时候犯了一个错误，感觉值得记录：
# 错误示例 class Solution(object): def canJump(self, nums): if len(nums) == 1: return True cur = 0 cover = nums[0] while cur <= cover: # cur+1这一行只能放在while循环的最后一句 # 因为当cur=cover进入循环之后，马上又+1 # 会让cur跑到cover外面去 # 所以应该是执行下面的逻辑之前，需要保证cur在cover范围内的 cur += 1 cover = max(cover, nums[cur]+cur) if cover >= len(nums)-1: return True return Falsecur+1这一行只能放在while循环的最后一句；因为当cur=cover进入循环之后，马上又+1；会让cur跑到cover外面去； 所以应该是执行下面的逻辑之前，需要保证cur在cover范围内的；
-
这道题目关键点在于：不用拘泥于每次究竟跳跳几步，而是看覆盖范围，覆盖范围内一定是可以跳过来的，不用管是怎么跳的；大家可以看出思路想出来了，代码还是非常简单的；
-
讲贪心系列的时候，题目和题目之间貌似没有什么联系？是真的就是没什么联系，因为贪心无套路！没有个整体的贪心框架解决一些列问题，只能是接触各种类型的题目锻炼自己的贪心思维！
Reference：代码随想录 (programmercarl.com)
本题学习时间：40分钟。
LeetCode45. 跳跃游戏II
1. 思路
本题相对于 LeetCode55.跳跃游戏 还是难了不少。但思路是相似的，还是要看最大覆盖范围；本题要计算最小步数，那么就要想清楚什么时候步数才一定要加一呢？
贪心的思路，局部最优：当前可移动距离尽可能多走，如果还没到终点，步数再加一。整体最优：一步尽可能多走，从而达到最小步数。
思路虽然是这样，但在写代码的时候还不能真的就能跳多远跳远，那样就不知道下一步最远能跳到哪里了。
所以真正解题的时候，要从覆盖范围出发，不管怎么跳，覆盖范围内一定是可以跳到的，以最小的步数增加覆盖范围，覆盖范围一旦覆盖了终点，得到的就是最小步数！
这里需要统计两个覆盖范围，当前这一步的最大覆盖和下一步最大覆盖。
如果移动下标达到了当前这一步的最大覆盖最远距离了，还没有到终点的话，那么就必须再走一步来增加覆盖范围，直到覆盖范围覆盖了终点。
图中覆盖范围的意义在于，只要红色的区域，最多两步一定可以到！（不用管具体怎么跳，反正一定可以跳到）
2. 代码实现
方法一
从图中可以看出来，就是移动下标达到了当前覆盖的最远距离下标时，步数就要加一，来增加覆盖距离。最后的步数就是最少步数。
这里还是有个特殊情况需要考虑，当移动下标达到了当前覆盖的最远距离下标时
- 如果当前覆盖最远距离下标不是是集合终点，步数就加一，还需要继续走。
- 如果当前覆盖最远距离下标就是是集合终点，步数不用加一，因为不能再往后走了。
class Solution(object):
def jump(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if len(nums) == 1: return 0
ans = 0 # 记录走的最大步数
curDistance = 0 # 当前覆盖最远距离下标
nextDistance = 0 # 下一步覆盖最远距离下标
for i in range(len(nums)):
# 更新下一步覆盖最远距离下标
nextDistance = max(i + nums[i], nextDistance)
# 遇到当前覆盖最远距离下标
if i == curDistance:
# 如果当前覆盖最远距离下标不是终点
if curDistance != len(nums) - 1:
# 需要走下一步
ans += 1
# 更新当前覆盖最远距离下标（相当于加油了）
curDistance = nextDistance
# 下一步的覆盖范围已经可以达到终点，结束循环
if nextDistance >= len(nums) - 1: break
# 当前覆盖最远距离下标是集合终点，不用做ans++操作了，直接结束
return ans
方法二
依然是贪心，思路和方法一差不多，代码可以简洁一些。
针对于方法一的特殊情况，可以统一处理，即：移动下标只要遇到当前覆盖最远距离的下标，直接步数加一，不考虑是不是终点的情况。
想要达到这样的效果，只要让移动下标，最大只能移动到nums.size - 2的地方就可以了。
因为当移动下标指向nums.size - 2时：
- 如果移动下标等于当前覆盖最大距离下标， 需要再走一步（即ans++），因为最后一步一定是可以到的终点。（题目假设总是可以到达数组的最后一个位置），如图：
- 如果移动下标不等于当前覆盖最大距离下标，说明当前覆盖最远距离就可以直接达到终点了，不需要再走一步。如图：
实现代码如下：
# 贪心版本二
class Solution:
def jump(self, nums: List[int]) -> int:
if len(nums) == 1:
return 0
curDistance, nextDistance = 0, 0
step = 0
for i in range(len(nums)-1):
nextDistance = max(nextDistance, nums[i]+i)
if i == curDistance:
curDistance = nextDistance
step += 1
return step
可以看出版本二的代码相对于版本一简化了不少！
其精髓在于控制移动下标i只移动到nums.size() - 2的位置，所以移动下标只要遇到当前覆盖最远距离的下标，直接步数加一，不用考虑别的了。
3. 复杂度分析
时间复杂度：O(N）；
需要遍历数组一次；
空间复杂度：O(1）
只有常数个变量来记录；
4. 思考与收获
- 这道题目相当于LeetCode55.跳跃游戏难了不止一点；但代码又十分简单，贪心就是这么巧妙；
- 理解本题的关键在于：以最小的步数增加最大的覆盖范围，直到覆盖范围覆盖了终点，这个范围内最小步数一定可以跳到，不用管具体是怎么跳的，不纠结于一步究竟跳一个单位还是两个单位；
Reference：代码随想录 (programmercarl.com)
本题学习时间：120分钟。
本篇学习时间约为3小时，总结字数5000+；是贪心算法相关的三道题，贪心算法没有什么固定的套路，只能多做一些题目，积累贪心算法的思路和经验。（求推荐！）
519
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
