leetcode-4.30[112. 路径总和、118. 杨辉三角、121. 买卖股票的最佳时机]（python实现)

题目1

题解1

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def hasPathSum(self, root: TreeNode, sum: int) -> bool:
        # 边界条件，如果为None则返回flase
        if root is None:
            return False
        # 每次左右两边的递归分别用sum减去该值
        sum -= root.val
        # 返回左右节点不存在(叶子节点)的时sum是否刚好减完
        if not root.left and not root.right:
            return sum == 0
        # 最终结果有一个为True，则证明有一条路径可以正好等于sum
        return self.hasPathSum(root.left, sum) or self.hasPathSum(root.right, sum)

附上题目链接

题目2

题解2

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        res = []
        for i in range(numRows):
            # 根据每一行的个数给每个元素附上1
            now = [1]*(i+1)
            # 从第三行开始，才和上一层有关系
            if i >= 2:
                # 因为每一行的两端都为1，所以遍历每一行除去两端的值
                for j in range(1,i):
                    # 将上一层的该下标左边值加上一层该下标的值赋给该层该下标处
                    now[j] = pre[j-1] + pre[j]
            res += [now]
            # 保存上层值
            pre = now
        return res


    # 动态规划
    def generate(self, num_rows):
        triangle = []

        for row_num in range(num_rows):
            # 初始化下一层
            row = [None for _ in range(row_num+1)]
            # 每一层的第一个元素和最后一个元素赋值1
            row[0], row[-1] = 1, 1
            # 重新给每一层的第1到i-1个元素赋值
            for j in range(1, len(row)-1):
                row[j] = triangle[row_num-1][j-1] + triangle[row_num-1][j]

            triangle.append(row)

        return triangle

附上题目链接

题目3

题解3

class Solution:
    # 分治算法
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        if n <= 1:
            return 0
        mid = n//2
        left = prices[:mid]
        right = prices[mid:]
        
        left_price = self.maxProfit(left)
        right_price = self.maxProfit(right)
        left_right_price = max(right) - min(left)
        return max(left_price, right_price, left_right_price)

    # 动态规划
    def maxProfit(self, prices: List[int]) -> int:
        """
        input: [7,1,5,3,6,4]
        子问题：DP[i]为到第i个元素时股票赚的最多
        子问题之间的关系: DP[i] = max(DP[i-1], A[i]- min_price]) 用min记录下的到i个元素的最小值下标
        边界条件: DP[0] = 0
        建表:  i  0  1  2  3  4  5
            A[i]  7  1  5  3  6  4
       min_price  7  1  1  1  1  1
            D[i]  0  0  4  4  5  5
        """
        n = len(prices)
        if n <= 0:
            return 0
        DP = [None]*n
        DP[0] = 0
        min_price = prices[0]
        for i in range(1,n):
            min_price = min(min_price, prices[i])
            DP[i] = max(DP[i-1],prices[i]-min_price)
            print(min_price)
        return max(DP)

附上题目链接