给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
示例:
输入：n = 4, k = 2 输出: [ [2,4], [3,4], [2,3], [1,2], [1,3], [1,4], ]
输入：n = 1, k = 1 输出：[[1]]

S1 确定变量和参数
def backtracking(self, n, k, startIndex, path, result):
“”"
:param startIndex:记录本层递归的中，集合从哪里开始遍历
:param path: 用来存放符合条件结果
:param result: 存放符合条件结果的集合
“”"

S2 回溯终止条件
path这个数组的大小如果达到k，说明我们找到了一个子集大小为k的组合了，在图中path存的就是根节点到叶子节点的路径。如图红色部分：

此时用result二维数组，把path保存起来，并终止本层递归。
if (path.size() == k) {
result.push_back(path);
return;
}

S3 单层搜索逻辑
回溯法的搜索过程就是一个树型结构的遍历过程，在如下图中，可以看出for循环用来横向遍历，递归的过程是纵向遍历。
for循环每次从startIndex开始遍历，然后用path保存取到的节点i。
for (int i = startIndex; i <= n; i++) { // 控制树的横向遍历
path.push_back(i); // 处理节点
backtracking(n, k, i + 1); // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
path.pop_back(); // 回溯，撤销处理的节点
}
可以看出backtracking（递归函数）通过不断调用自己一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回。
backtracking的下面部分就是回溯的操作了，撤销本次处理的结果。

代码如下（Python3）：

class Solution:
    def combine(self, n: int, k: int) -> List[List[int]]:
        result = []  # 存放结果集
        self.backtracking(n, k, 1, [], result)
        return result
    def backtracking(self, n, k, startIndex, path, result):
        if len(path) == k:
            result.append(path[:])
            return
        for i in range(startIndex, n + 1):  # 需要优化的地方
            path.append(i)  # 处理节点
            self.backtracking(n, k, i + 1, path, result)
            path.pop()  # 回溯，撤销处理的节点

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

只使用数字1到9
每个数字 最多使用一次
返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1: 输入: k = 3, n = 7 输出: [[1,2,4]]
示例 2: 输入: k = 3, n = 9 输出: [[1,2,6], [1,3,5], [2,3,4]]

本题k相当于树的深度，9（因为整个集合就是9个数）就是树的宽度。

确定参数
和77组合一样，依然需要一维数组path来存放符合条件的结果，二维数组result来存放结果集。
targetSum（int）目标和，也就是题目中的n。
k（int）就是题目中要求k个数的集合。
sum（int）为已经收集的元素的总和，也就是path里元素的总和。
startIndex（int）为下一层for循环搜索的起始位置。

确定终止条件
在上面已经说了，k其实就已经限制树的深度，因为就取k个元素，树再往下深了没有意义。
所以如果path.size() 和 k相等了，就终止。
如果此时path里收集到的元素和（sum） 和targetSum（就是题目描述的n）相同了，就用result收集当前的结果。

确定单层搜索逻辑
本题和77组合区别之一就是集合固定的就是9个数[1,…,9]，所以for循环固定i<=9
处理过程就是 path收集每次选取的元素，相当于树型结构里的边，sum来统计path里元素的总和。

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 1：
输入：digits = “23”
输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]

示例 2：
输入：digits = “”
输出：[ ]

示例 3：
输入：digits = “2”
输出：[“a”,“b”,“c”]

遍历的深度就是输入"23"的长度，宽度就是每个数字对应字符串的长度
而叶子节点就是我们要收集的结果，输出[“ad”, “ae”, “af”, “bd”, “be”, “bf”, “cd”, “ce”, “cf”]

确定回溯函数参数
首先需要一个字符串s来收集叶子节点的结果，然后用一个字符串数组result保存起来，这两个变量我依然定义为全局。
再来看参数，参数指定是有题目中给的string digits，然后还要有一个参数就是int型的index。
注意这个index可不是 77组合和216组合总和Ⅲ中的startIndex了。
因为本题是多个集合求组合，这个index是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度。

确定终止条件
例如输入用例"23"，两个数字，那么根节点往下递归两层就可以了，叶子节点就是要收集的结果集。
那么终止条件就是如果index 等于 输入的数字个数（digits.size）了（本来index就是用来遍历digits的）。
然后收集结果，结束本层递归。

确定单层遍历逻辑
首先要取index指向的数字，并找到对应的字符集（手机键盘的字符集）。
然后for循环来处理这个字符集

from typing import List

class Solution:
    def __init__(self):
        self.letterMap = [
            "",  # 0
            "",  # 1
            "abc",  # 2
            "def",  # 3
            "ghi",  # 4
            "jkl",  # 5
            "mno",  # 6
            "pqrs",  # 7
            "tuv",  # 8
            "wxyz"  # 9
        ]
        self.res = []
        self.s = ""

    def letterCombinations(self, digits: str) -> List[str]:
        if len(digits) == 0:  # 数字为空直接返回空res
            return self.res
        self.backtracking(digits, 0)
        return self.res

    def backtracking(self, digits, index):
        if index == len(digits):  # 索引等于数字个数
            self.res.append(self.s)
            return

        digit = int(digits[index])  # 将索引处的数字转为整数
        letters = self.letterMap[digit]  # 获取对应的字符集
        for i in range(len(letters)):
            self.s += letters[i]  # 处理字符
            self.backtracking(digits, index + 1)  # 递归调用，注意索引加1，处理下一个数字
            self.s = self.s[:-1]  # 回溯，删除最后添加的元素

S = Solution()
print(S.letterCombinations("23"))