1、排列序列（递归，数学）
给出集合 [1,2,3,...,n]，其所有元素共有 n! 种排列。
按大小顺序列出所有排列情况，并一一标记，当 n = 3 时, 所有排列如下：
- "123"
- "132"
- "213"
- "231"
- "312"
- "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 <= 200triangle[0].length == 1triangle[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)
