代码随想录算法训练营第二十二天 | 回溯理论基础、77. 组合、216.组合总和III、17.电话号码的字母组合

一、回溯理论基础

文章讲解：代码随想录 (programmercarl.com)——回溯理论基础
视频讲解：带你学透回溯算法（理论篇）| 回溯法精讲！_哔哩哔哩_bilibili

 1. 解决问题

（1）组合问题：N个数里面按一定规则找出k个数的集合；
（2）切割问题：给一个字符串，问右几种切割方式；
（3）子集问题：N个数有多少个符合条件的子集；
（4）排列问题：强调元素顺序；
（5）棋盘问题：N皇后，解数独等。

2. 如何理解回溯法

所有回溯法都可抽象为一个N叉树

3. 回溯法模板

def backtracking(self, 参数):
    if 终止条件:
        return

    for 选择 in 集合元素(树中节点孩子的数量就是集合的大小):
        处理节点
        self.backtrack(递归函数)
        回溯操作，撤销处理节点
        return

二、77. 组合

题目链接：77. 组合 - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——77. 组合
视频讲解：带你学透回溯算法-组合问题（对应力扣题目：77.组合）| 回溯法精讲！_哔哩哔哩_bilibili

回溯算法通过递归控制有多少层 for 循环，递归中每一层就是一层 for 循环。

树形结构：

回溯三部曲：
1. 确定递归函数的参数和返回值；
2. 确定递归终止条件；
3. 确定单层递归逻辑。

1. 未剪枝优化

"""
未剪枝
"""
class Solution:
    # 1. 确定递归函数的参数和返回值
    # startindex：本次搜索时候的起始位置
    # path：一维数组就是结果，即路径；
    # result：二维数组，返回最终结果
    def backtracking(self, n: int, k: int, startindex: int, path, result):
        # 2. 确定终止条件，路径数量等于k个数的
        if len(path) == k:
            result.append(path[:])
            return

        # 3. 确定单层递归逻辑
        for i in range(startindex, n + 1):    # 需要剪枝优化
            # 处理当前节点
            path.append(i)
            # 递归
            self.backtracking(n, k, i + 1, path, result)
            # 回溯，处理撤销节点
            path.pop()


    def combine(self, n: int, k: int) -> List[List[int]]:
        result = []
        self.backtracking(n, k, 1, [], result)
        return result

2. 剪枝优化

视频讲解：带你学透回溯算法-组合问题的剪枝操作（对应力扣题目：77.组合）| 回溯法精讲！_哔哩哔哩_bilibili

剪枝操作：修改for循环的范围，len(path)表示已经选取元素的大小，用 (k - len(path) 得到还需要选取元素的个数，至多还剩 (n - ( k - len(path) ) + 2) 个元素需要选取，range函数为左闭右开区间。

"""
剪枝优化
"""
class Solution:
    # 1. 确定递归函数的参数和返回值
    # startindex：本次搜索时候的起始位置
    # path：一维数组就是结果，即路径；
    # result：二维数组，返回最终结果
    def backtracking(self, n: int, k: int, startindex: int, path, result):
        # 2. 确定终止条件，路径数量等于k个数的
        if len(path) == k:
            result.append(path[:])
            return

        # 3. 确定单层递归逻辑
        for i in range(startindex, n - (k - len(path)) + 2):    # 剪枝优化，修改for循环范围
            # 处理当前节点
            path.append(i)
            # 递归
            self.backtracking(n, k, i + 1, path, result)
            # 回溯，处理撤销节点
            path.pop()


    def combine(self, n: int, k: int) -> List[List[int]]:
        result = []
        self.backtracking(n, k, 1, [], result)
        return result

Note：剪枝操作一般都在循环范围处做文章。

三、216.组合总和III

题目链接：216. 组合总和 III - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——216.组合总和III
视频讲解：和组合问题有啥区别？回溯算法如何剪枝？| LeetCode：216.组合总和III_哔哩哔哩_bilibili

思路：k控制树的深度

class Solution:
    # 1. 确定递归函数的参数和返回值
    # path，一维数组，存储组合
    # result，二维数组，存储结果
    def backtracking(self, targetsum, k, sum, startindex, path, result):
        # 2. 确定递归终止条件
        # 当前和大于目标和，剪枝
        if sum > targetsum:
            return
        # 组合中的个数与k相等
        if len(path) == k:
            # 组合的和与目标值相等
            if sum == targetsum:
                result.append(path[:])
            return
        
        # 3. 确定单层递归逻辑
        for i in range(startindex, 9 - (k - len(path)) + 2):
            sum += i
            path.append(i)
            self.backtracking(targetsum, k, sum, i + 1, path, result)  # 递归，注意staertindex从i+1，即下一个数开始取
            sum -= i                                                   # 回溯
            path.pop()                                                 # 回溯


    def combinationSum3(self, k: int, n: int) -> List[List[int]]:
        result = []
        # targetsum为n，初始sum为0，startindex为1
        self.backtracking(n, k, 0, 1, [], result)
        return result

四、17.电话号码的字母组合

题目链接：17. 电话号码的字母组合 - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——17.电话号码的字母组合
视频讲解：还得用回溯算法！| LeetCode：17.电话号码的字母组合_哔哩哔哩_bilibili

思路：先用map做一个映射，构造n叉树，结果为n叉树的叶子节点。输入数字的个数，控制树的深度；每一个数字对应字母的长度，控制树的宽度。

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.result = []        # 存储最终结果
        self.s = ""             # 单个需要结果

    # 1. 确定递归函数的参数和返回值
    # digits 为输入数字
    # index 表示递归中传入的字符串遍历到哪一个数字了
    def backtracking(self, digits, index):
        # 2. 确定递归终止条件，index遍历到digits末尾的时候结束
        if index == len(digits):
            self.result.append(self.s)
            return
        
        # 3. 确定单层递归逻辑
        digit = int(digits[index])                     # 将索引处的数字转换为整数
        letters = self.letterMap[digit]                # 找数字对应的字符串
        for i in range(len(letters)):
            self.s += letters[i]                        # 用 += 连接不同字符串
            self.backtracking(digits, index + 1)        # 递归
            self.s = self.s[:-1]                        # 回溯，移除最后一个字符


    def letterCombinations(self, digits: str) -> List[str]:
        if len(digits) == 0:
            return self.result
        self.backtracking(digits, 0)
        return self.result