TLP-Task10学习笔记

最新推荐文章于 2021-01-28 02:46:47 发布

cosima0

最新推荐文章于 2021-01-28 02:46:47 发布

阅读量132

点赞数

分类专栏： TLP

本文链接：https://blog.csdn.net/cosima0/article/details/112972877

版权

TLP 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

121 买卖股票的最佳时机

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。
注意：你不能在买入股票前卖出股票。

示例:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

思路

官解中一次遍历的思路：
在第i天，决定在当天卖出，就要找到之前那些天里历史最低点买入。该价格就用minprice记录。
假如计划在第 i 天卖出股票，那么最大利润一定要在[0, i-1] 之间选最低点买入，用maxprofit记录；
遍历数组，依次求每天（i)卖出时能得到的最大差值，并更新历史最低价格，遍历结束取利润的最大值。

Python实现

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        inf = int(1e9)
        minprice = inf  # 历史最低买入价格
        maxprofit = 0   # 第i天卖出时能获得的最大利润
        for i in prices:
            maxprofit = max(i - minprice, maxprofit)    # 遍历找到最大利润
            minprice = min(i, minprice)                 # 更新历史最低价格
        return maxprofit

122 买卖股票的最佳时机Ⅱ

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii

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

示例

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

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

注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

思路

股票类题目合集可参考股票问题系列通解（转载翻译
本题常见的两种算法：动态规划（比较通用）、贪心算法（稍有特殊）。
贪心算法：局部最优解→全局最优解

「贪心算法」和「动态规划」、「回溯搜索」算法一样，完成一件事情，是分步决策的；
「贪心算法」在每一步总是做出在当前看来最好的选择，我是这样理解「最好」这两个字的意思：
「最好」的意思往往根据题目而来，可能是「最小」，也可能是「最大」；
贪心算法和动态规划相比，它既不看前面（也就是说它不需要从前面的状态转移过来），也不看后面（无后效性，后面的选择不会对前面的选择有影响），因此贪心算法时间复杂度一般是线性的，空间复杂度是常数级别的；

这道题「贪心」的地方在于，对于「今天的股价 - 昨天的股价」，得到的结果有 3 种可能：① 正数，② 000，③负数。贪心算法的决策是： 只加正数 。

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/solution/tan-xin-suan-fa-by-liweiwei1419-2/

Python实现

（datawhale学习文档）

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        earn = 0
        for i in range(0, len(prices) - 1):
            earn += max(prices[i + 1] - prices[i], 0)
        return earn

124 二叉树中的最大路径和

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-maximum-path-sum

路径被定义为一条从树中任意节点出发，沿父节点-子节点连接，达到任意节点的序列。该路径 至少包含一个 节点，且不一定经过根节点。
路径和 是路径中各节点值的总和。
给你一个二叉树的根节点 root ，返回其最大路径和。

示例：

输入：root = [1,2,3]
输出：6
解释：最优路径是 2 -> 1 -> 3 ，路径和为 2 + 1 + 3 = 6

输入：root = [-10,9,20,null,null,15,7]
输出：42
解释：最优路径是 15 -> 20 -> 7 ，路径和为 15 + 20 + 7 = 42

提示：

树中节点数目范围是 [1, 3 * 10^4]
-1000 <= Node.val <= 1000

思路

对于任意一个节点, 如果最大和路径包含该节点, 那么只可能是两种情况：
其左右子树中所构成的和路径值较大的那个加上该节点的值后向父节点回溯构成最大路径。
左右子树都在最大路径中, 加上该节点的值构成了最终的最大路径。

官方题解中的递归思路：

首先，考虑实现一个简化的函数 maxGain(node)，该计算二叉树中的一个节点的最大贡献值，

具体而言，就是在以该节点为根节点的子树中寻找以该节点为起点的一条路径，使得该路径上的节点值之和最大。
该函数的计算如下:

空节点的最大贡献值等于0。
非空节点的最大贡献值等于节点值与其子节点中的最大贡献值之和（对于叶节点而言，最大贡献值等于节点值）。

先考虑叶节点贡献值，再考虑非叶节点

例如，考虑如下二叉树。

叶节点9、15、7 的最大贡献值分别为9、15、7。
再计算非叶节点的最大贡献值。节点20的最大贡献值等于20+max(15,7)=35，节点-10的最大贡献值等于-10+max(9,35)=25。

上述计算过程是递归的过程，因此，对根节点调用函数 maxGain，即可得到每个节点的最大贡献值。

二叉树的最大路径和

对于二叉树中的一个节点，该节点的最大路径和取决于该节点的值与该节点的左右子节点的最大贡献值，如果子节点的最大贡献值为正，则计入该节点的最大路径和，否则不计入该节点的最大路径和。维护一个全局变量 maxSum 存储最大路径和，在递归过程中更新 maxSum 的值，最后得到的 maxSum 的值即为二叉树中的最大路径和。

Python实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def __init__(self):
        self.maxSum = float("-inf")

    def maxPathSum(self, root: TreeNode) -> int:
        def maxGain(node):
            if not node:
                return 0

            # 递归计算左右子节点的最大贡献值
            # 只有在最大贡献值大于 0 时，才会选取对应子节点
            leftGain = max(maxGain(node.left), 0)
            rightGain = max(maxGain(node.right), 0)
            
            # 节点的最大路径和取决于该节点的值与该节点的左右子节点的最大贡献值
            priceNewpath = node.val + leftGain + rightGain
            
            # 更新答案
            self.maxSum = max(self.maxSum, priceNewpath)
        
            # 返回节点的最大贡献值
            return node.val + max(leftGain, rightGain)
   
        maxGain(root)
        return self.maxSum

# 作者：LeetCode-Solution
# 链接：https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/solution/er-cha-shu-zhong-de-zui-da-lu-jing-he-by-leetcode-/
# 来源：力扣（LeetCode）
# 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。