代码随想录算法训练营第32天|● 122.买卖股票的最佳时机II ● 55. 跳跃游戏 ● 45.跳跃游戏II

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

中等
给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。

示例 1：
输入：prices = [7,1,5,3,6,4]输出：7解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
示例 2：
输入：prices = [1,2,3,4,5]输出：4解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4 。
示例 3：
输入：prices = [7,6,4,3,1]输出：0解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0 。

提示：

• 1 <= prices.length <= 3 * 10(4)
• 0 <= prices[i] <= 10(4)
  思路
• 把利润分解为每天为单位的维度
• 只收集正利润就是贪心所贪的地方！
• 局部最优：收集每天的正利润，全局最优：求得最大利润。

代码

func maxProfit(prices []int) int {
    n := len(prices)
    max_price := 0

    for i:=1;i<n;i++{
        if prices[i]-prices[i-1]>0{
            max_price+=prices[i]-prices[i-1]
        }
    }
    return max_price
}
func maxProfit(prices []int) int {
   n, res := len(prices), 0
   //进栈,找递增数列
   stack := make([]int, 0)
   stack = append(stack, prices[0])
   for i := 1; i < n; i++ {
      if len(stack) != 0 && stack[len(stack)-1] > prices[i] {//比栈顶大，弹出
         x, y := stack[0], stack[len(stack)-1]
         res += y - x
         stack = make([]int, 0)
      }
      stack = append(stack, prices[i])
   }
   if len(stack) != 0 {
      x, y := stack[0], stack[len(stack)-1]
      res += y - x
   }
   return res
}

55. 跳跃游戏

中等
给你一个非负整数数组 nums ，你最初位于数组的 第一个下标 。数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标，如果可以，返回 true ；否则，返回 false 。

示例 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 <= 10(4)
• 0 <= nums[i] <= 10(5)

代码

func canJump(nums []int) bool {
   n := len(nums)
   nextPos := 0
   for i := 0; i < n; i++ {
      if i > nextPos+nums[nextPos] { //超出跳跃范围
         return false
      }
      if i+nums[i] >= nextPos+nums[nextPos] { //下一步跳跃，更新范围
         nextPos = i
      }

   }
   return true
}

45. 跳跃游戏 II

中等
给定一个长度为 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。1 步，然后跳 3 步到达数组的最后一个位置。
示例 2:
输入: nums = [2,3,0,1,4]输出: 2

提示:

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

思路

• 其精髓在于控制移动下标 i 只移动到 nums.size() - 2 的位置

代码

// 贪心版本一
func jump(nums []int) int {
    n := len(nums)
    if n == 1 {
        return 0
    }
    cur, next := 0, 0 // 当前覆盖最远距离下标， 下一步覆盖最远距离下标
    step := 0
    for i := 0; i < n; i++ {
        next = max(nums[i]+i, next)// 更新下一步覆盖最远距离下标
        if i == cur {// 遇到当前覆盖最远距离下标
            if cur != n-1 {// 需要走下一步
                step++
                cur = next// 更新当前覆盖最远距离下标（相当于加油了）
                if cur >= n-1 { // 当前覆盖最远距到达集合终点，不用做ans++操作了，直接结束}
                    return step
                }
            } else {
                return step
            }
        }
    }
    return step
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}