Python|每日一练|递归|数学|数组|动态规划|树|深度优先搜索|单选记录：排列序列|三角形最小路径和|求根节点到叶节点数字之和

1、排列序列（递归，数学）

给出集合 [1,2,3,...,n]，其所有元素共有 n! 种排列。

按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：

1. "123"
2. "132"
3. "213"
4. "231"
5. "312"
6. "321"

给定 n 和 k，返回第 k 个排列。

 

示例 1：

输入：n = 3, k = 3
输出："213"

示例 2：

输入：n = 4, k = 9
输出："2314"

示例 3：

输入：n = 3, k = 1
输出："123"

 

提示：

• 1 <= n <= 9
• 1 <= k <= n!

以下程序实现了这一功能，请你填补空白处内容：

class Solution(object):
    def getPermutation(self, n, k):
        """
      :type n: int
      :type k: int
      :rtype: str
      """
        import math
        res = [""]

        def generate(s, k):
            n = len(s)
            if n <= 2:
                if k == 2:
                    res[0] += s[::-1]
                else:
                    res[0] += s
                return
            step = math.factorial(n - 1)
            yu = k % step
            if yu == 0:
                yu = step
                c = k // step - 1
            else:
                c = k // step
            res[0] += s[c]
            ____________________;
            return

        s = ""
        for i in range(1, n + 1):
            s += str(i)
        generate(s, k)
        return res[0]


if __name__ == '__main__':
    s = Solution()
    print(s.getPermutation(3, 2))

选项代码：

class Solution(object):
    def getPermutation(self, n, k):
        """
      :type n: int
      :type k: int
      :rtype: str
      """
        import math
        res = [""]

        def generate(s, k):
            n = len(s)
            if n <= 2:
                if k == 2:
                    res[0] += s[::-1]
                else:
                    res[0] += s
                return
            step = math.factorial(n - 1)
            yu = k % step
            if yu == 0:
                yu = step
                c = k // step - 1
            else:
                c = k // step
            res[0] += s[c]
            generate(s[:c] + s[c + 1:], yu)
            return

        s = ""
        for i in range(1, n + 1):
            s += str(i)
        generate(s, k)
        return res[0]


if __name__ == '__main__':
    s = Solution()
    print(s.getPermutation(4, 9))

2、三角形最小路径和（数组，动态规划）

给定一个三角形 triangle ，找出自顶向下的最小路径和。

每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

 

示例 1：

输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]

输出：11

解释：如下面简图所示：

2

3 4

6 5 7

4 1 8 3

自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

示例 2：

输入：triangle = [[-10]]

输出：-10

 

提示：

• 1 <= triangle.length <= 200
• triangle[0].length == 1
• triangle[i].length == triangle[i - 1].length + 1
• -104 <= triangle[i][j] <= 104

 

进阶：

• 你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题吗？

选项代码：

class Solution(object):
    def minimumTotal(self, triangle):
        """
        :type triangle: List[List[int]]
        :rtype: int
        """
        n = len(triangle)
        dp = triangle[-1]
        for i in range(n - 2, -1, -1):
            for j in range(i + 1):
                dp[j] = triangle[i][j] + min(dp[j], dp[j + 1])
        print(dp)
        return dp[0]
if __name__ == "__main__":
    triangle = [[2], [3, 4], [6, 5, 7], [4, 1, 8, 3]]
    s = Solution()
    print(s.minimumTotal(triangle))

3、求根节点到叶节点数字之和（树，深度优先搜索）

给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。

每条从根节点到叶节点的路径都代表一个数字：

• 例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123 。

计算从根节点到叶节点生成的 所有数字之和 。

叶节点 是指没有子节点的节点。

 

示例 1：

输入：root = [1,2,3]

输出：25

解释：

从根到叶子节点路径 1->2 代表数字 12

从根到叶子节点路径 1->3 代表数字 13

因此，数字总和 = 12 + 13 = 25

示例 2：

输入：root = [4,9,0,5,1]

输出：1026

解释：

从根到叶子节点路径 4->9->5 代表数字 495

从根到叶子节点路径 4->9->1 代表数字 491

从根到叶子节点路径 4->0 代表数字 40

因此，数字总和 = 495 + 491 + 40 = 1026

 

提示：

• 树中节点的数目在范围 [1, 1000] 内
• 0 <= Node.val <= 9
• 树的深度不超过 10

选项代码：

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    def sumNumbers(self, root: TreeNode) -> int:
        def dfs(root: TreeNode, sumNumber: int) -> int:
            if not root:
                return 0
            tmpsum = sumNumber * 10 + root.val
            if not root.left and not root.right:
                return tmpsum
            else:
                return dfs(root.left, tmpsum) + dfs(root.right, tmpsum)
        return dfs(root, 0)