代码随想录算法训练营第二十二天 | 回溯理论基础、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 循环。

树形结构:代码随想录算法训练营第二十二天 | 回溯理论基础、77. 组合、216.组合总和III、17.电话号码的字母组合_第1张图片

回溯三部曲:
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

你可能感兴趣的:(代码随想录算法训练营,算法)