leetcode python刷题记录（十二）（111~120）

leetcode python刷题记录（十二）（111~120）

111. 二叉树的最小深度

class Solution:
    def minDepth(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        depth=[]

        # dfs所有深度，最后返回最小的即可
        def dfs(node,d):
            if not node.left and not node.right:
                depth.append(d)
                return

            d=d+1

            if node.left:
                dfs(node.left,d)
            if node.right:
                dfs(node.right,d)

        dfs(root,1)

        return min(depth)

112. 路径总和

class Solution:
    def hasPathSum(self, root: Optional[TreeNode], targetSum: int) -> bool:
        if not root:
            return False
        path=[] # 记录每一条支路的总和
        
        def dfs(root,sum):
            if not root:
                return
            sum=sum+root.val

            if not root.left and not root.right: # 如果是叶子节点才将总和放到list里面
                path.append(sum)

            dfs(root.left,sum)
            dfs(root.right,sum)

        dfs(root,0)

        if targetSum in path:
            return True
        else:
            return False

113. 路径总和 II

dfs：

class Solution:
    def pathSum(self, root: Optional[TreeNode], targetSum: int) -> List[List[int]]:

        path=[]
        res=[]

        def dfs(root,sum,path):
            if not root:
                return
            if not root.left and not root.right:
                if sum == root.val:
                    path=path+[root.val]
                    res.append(path)
            dfs(root.left,sum-root.val,path+[root.val])
            dfs(root.right,sum-root.val,path+[root.val])

        dfs(root,targetSum,path)
        
        return res

114. 二叉树展开为链表

class Solution:
    def flatten(self, root: Optional[TreeNode]) -> None:
        """
        Do not return anything, modify root in-place instead.
        """
        preorderList = list()

        # 前序遍历，结果存到preorderList
        def preorderTraversal(root: TreeNode):
            if root:
                preorderList.append(root)
                preorderTraversal(root.left)
                preorderTraversal(root.right)
        
        preorderTraversal(root)
        
        # 节点一个个连接，形成单链表
        for i in range(1, len(preorderList)):
            prev, curr = preorderList[i - 1], preorderList[i]
            prev.left = None
            prev.right = curr

115. 不同的子序列

class Solution:
    def numDistinct(self, s: str, t: str) -> int:
        m,n=len(s),len(t)

        # 在 s 串身上 “挑选” 字符，去匹配 t 串的字符，求挑选的方式数
        # 用d[i][j]表示s的前i个字符包含t前j个字符的个数，状态转移方程需要考虑s的第i个字符和t的第j个字符是否匹配。
        dp=[[0]*(n+1) for _ in range(m+1)]

        for i in range(m+1):
            dp[i][0]=1

        for i in range(1,m+1):
            for j in range(1,n+1):
                dp[i][j]=dp[i-1][j]
                if s[i-1]==t[j-1]:
                    dp[i][j]=dp[i][j]+dp[i-1][j-1]

        return dp[m][n]

116. 填充每个节点的下一个右侧节点指针

class Solution:
    def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
        # 非叶结点都有两个孩子，左右孩子必定相邻，所以左孩子的 next 指针应当指向右孩子
        # 右孩子的 next 指针应当指向 父节点 next 所指结点 的左孩子（如 Figure B 所示，结点5的next应当指向 其父节点2 的 next 指针所指结点3 的左孩子）

        if root:
            if root.left:
                root.left.next=root.right
                if root.next:
                    root.right.next=root.next.left
            self.connect(root.left)
            self.connect(root.right)

        return root

117. 填充每个节点的下一个右侧节点指针 II

class Solution:
    def connect(self, root: 'Node') -> 'Node':

        # 思路：每一层拿出来放到queue里，然后两两连接即可
        if not root:
            return root
        
        # pairwise:从对象中获取连续的重叠对
        # 比如说：s= ‘abcde’，itertools.pairwise(s)的输出应该为，ab, bc, cd, de;
        
        queue=[root]

        while queue:
            temp=queue
            queue=[]

            for x,y in pairwise(temp):
                x.next=y

            for node in temp:
                if node.left:
                    queue.append(node.left)
                if node.right:
                    queue.append(node.right)

        return root

118. 杨辉三角

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        res=[]

        for i in range(numRows):
            row=[]
            for j in range(0,i+1):
                if j==0 or j==i:
                    row.append(1)
                else:
                    row.append(res[i-1][j]+res[i-1][j-1])
            res.append(row)

        return res

119. 杨辉三角 II

class Solution:
    def getRow(self, rowIndex: int) -> List[int]:

        res=[]

        for i in range(rowIndex+1):
            row=[]
            for j in range(0,i+1):
                if j==0 or i==j:
                    row.append(1)
                else:
                    row.append(res[i-1][j]+res[i-1][j-1])
            res.append(row)
        
        return res[rowIndex]

120. 三角形最小路径和

class Solution:
    def minimumTotal(self, triangle: List[List[int]]) -> int:
        
        # 由下向上计算
        triangle=triangle[::-1]

        for i in range(1,len(triangle)):
            for j in range(len(triangle[i])):
                triangle[i][j]=triangle[i][j]+min(triangle[i-1][j],triangle[i-1][j+1])

        return triangle[-1][-1]