代码随想录算法训练营第三十七天| LeetCode738. 单调递增的数字、LeetCode714. 买卖股票的最佳时机含手续费、LeetCode968. 监控二叉树

一、LeetCode738. 单调递增的数字

        1：题目描述（738. 单调递增的数字）

        当且仅当每个相邻位数上的数字 x 和 y 满足 x <= y 时，我们称这个整数是单调递增的。

        给定一个整数 n ，返回 小于或等于 n 的最大数字，且数字呈 单调递增 。

        2：解题思路

class Solution:
    def monotoneIncreasingDigits(self, n: int) -> int:
        a_list = list(str(n))           # 将整数转换成字符串，再将其转换为列表
        # 从后往前进行遍历
        # 当前元素的值小于前一个元素的值，说明整数不是单调递增的
        # 需要把前一个元素的值减1，将当前元素及其之后的元素置为9，即可获得最大的数字，并成单调递增
        for i in range(len(a_list)-1, 0, -1):
            # 列表中的元素均为str类型，需要将其转换为int类型
            if int(a_list[i]) < int(a_list[i-1]):
                # 将前一个元素的值，自减1
                a_list[i-1] = str(int(a_list[i-1]) - 1)
                # 把当前元素及其之后的元素，都置为9
                a_list[i:] = "9" * (len(a_list)-i)
        # 将得到的a_list，拼接成字符串，再转换为int类型
        return int("".join(a_list))

二、LeetCode714. 买卖股票的最佳时机含手续费

        1：题目描述（714. 买卖股票的最佳时机含手续费）

        给定一个整数数组 prices，其中 prices[i]表示第 i 天的股票价格 ；整数 fee 代表了交易股票的手续费用。

        你可以无限次地完成交易，但是你每笔交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。

        返回获得利润的最大值。

        注意：这里的一笔交易指买入持有并卖出股票的整个过程，每笔交易你只需要为支付一次手续费。

        2：解题思路

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        result = 0
        minprice = prices[0]            # 记录最低的股票价格
        for i in range(1, len(prices)):
            if prices[i] < minprice:
                # 若当前股票价格小于最低价格，则重新复制最低价格
                minprice = prices[i]
            elif prices[i] >= minprice and prices[i] <= minprice + fee:
                # 若当前股票价格大于最低价格，但小于最低价格+手续费，则不买入也不卖出，继续遍历
                continue
            else:
                # 若当前股票价格大于最低价格，且大于最低价格+手续费，可以进行已最低价格进行买入，当前价格进行卖出
                # 当前价格-最低价格-手续费，就是本次买入卖出的利润
                result += prices[i]-minprice-fee
                # 卖出后，修改最低价格，以当前价格减去手续费作为最低价格
                minprice = prices[i] - fee
        return result

三、LeetCode968. 监控二叉树

        1：题目描述（968. 监控二叉树）

        给定一个二叉树，我们在树的节点上安装摄像头。

        节点上的每个摄影头都可以监视其父对象、自身及其直接子对象。

        计算监控树的所有节点所需的最小摄像头数量。

        2：解题思路

        直接看：代码随想录：968. 监控二叉树

class Solution:
    def minCameraCover(self, root: TreeNode) -> int:
        # Greedy Algo:
        # 从下往上安装摄像头：跳过leaves这样安装数量最少，局部最优 -> 全局最优
        # 先给leaves的父节点安装，然后每隔两层节点安装一个摄像头，直到Head
        # 0: 该节点未覆盖
        # 1: 该节点有摄像头
        # 2: 该节点有覆盖
        
        result = 0
        # 从下往上遍历：后序（左右中）
        def traversal(curr: TreeNode) -> int:
            nonlocal result
            
            if not curr: return 2
            left = traversal(curr.left)
            right = traversal(curr.right)

            # Case 1:
            # 左右节点都有覆盖
            if left == 2 and right == 2: 
                return 0

            # Case 2:
                # left == 0 && right == 0 左右节点无覆盖
                # left == 1 && right == 0 左节点有摄像头，右节点无覆盖
                # left == 0 && right == 1 左节点有无覆盖，右节点摄像头
                # left == 0 && right == 2 左节点无覆盖，右节点覆盖
                # left == 2 && right == 0 左节点覆盖，右节点无覆盖
            elif left == 0 or right == 0: 
                result += 1
                return 1

            # Case 3:
                # left == 1 && right == 2 左节点有摄像头，右节点有覆盖
                # left == 2 && right == 1 左节点有覆盖，右节点有摄像头
                # left == 1 && right == 1 左右节点都有摄像头
            elif left == 1 or right == 1:
                return 2
            
            # 其他情况前段代码均已覆盖

        if traversal(root) == 0:
            result += 1
            
        return result