研习代码 day21 | 回溯的原理和经典例题（组合）

一、回溯

        1.1 使用场景

        需多维的暴力枚举，虽没有确切的递归层数的情况，但处理逻辑类似。

（我在之前的文章中说过：递归和回溯本就是不分离的，有递归的地方就有回溯，递归是往下，往下碰到终止条件之后就会开始回溯）

        1.2 原理

        用 for 语句完成横向遍历，用递归语句完成纵向遍历，在递归后的回溯过程中进行一定的操作

图片来自：代码随想录

        1.3 代码模板  

        此处的递归是否返回值：一般不需要，因为往往需遍历整个过程

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

二、组合

        2.1 题目

        给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：shi

• 1 <= n <= 20
• 1 <= k <= n

        2.2 题目链接

        77.组合

        2.3 解题思路和过程想法

        （1）解题思路

        这道题是典型的“需多维的暴力枚举，虽没有确切的递归层数的情况，但处理逻辑类似”，考虑使用回溯法。

        # 终止条件：找到符合条件的结果，并将其追加至最终结果中
        # 处理逻辑：for---横向遍历（遍历数组中所有的数字），递归---纵向遍历（遍历数组中剩下的数字，直到满足条件）
        # 递归函数的传入参数：需处理的开始位置 startIndex、基础参数 n 和 k、全局变量或向量类型的变量——本轮递归已遍历的路径 path 、最终的结果向量 res

        （2）过程想法

        刚开始正式接触回溯，但在之前有在二叉树中运用一定的回溯，所以也不算特别陌生，在直到处理逻辑后，上手的困难度不高。

        2.4 代码

        2.4.1 回溯+未剪枝

class Solution:
    def backStacking(self,n,k,startIndex):
        # 终止条件:找到符合条件的结果，并将其追加至最终结果中
        if len(self.path) == k:
            self.res.append(self.path[:])
            return

        # 处理逻辑:for---横向处理，递归---纵向处理
        for i in range(startIndex,n+1):
            self.path.append(i)         # 增加已遍历路径
            self.backStacking(n,k,i+1)  # 递归
            self.path.pop()             # 回溯时弹出

    def combine(self, n: int, k: int) -> List[List[int]]:
        # 利用递归来实现 k 层的遍历，需理解它的处理逻辑：for---横向处理，递归---纵向处理

        # 存放符合条件的结果
        self.path = []
        # 存放结果的二维数组
        self.res = []

        self.backStacking(n,k,1)

        return self.res

        2.4.2 回溯+剪枝

class Solution:
    def backStacking(self,n,k,startIndex,path,res):
        # 终止条件:找到符合条件的结果，并将其追加至最终结果中
        if len(path) == k:
            res.append(path[:])
            return

        # 处理逻辑:for---横向处理，递归---纵向处理
        # 剪枝：若剩下的元素不足 k ，则不必继续循环
        # 已选：len(path)  还需：k-len(path)
        # i = n - (k-len(path)) +1  还需加一，因为左闭右开
        # 截止位置 i= n - (k-len(path)) +2
        for i in range(startIndex,n-k+len(path)+2):
            path.append(i)         # 增加已遍历路径
            self.backStacking(n,k,i+1,path,res)  # 递归
            path.pop()             # 回溯时弹出

    def combine(self, n: int, k: int) -> List[List[int]]:
        # 利用递归来实现 k 层的遍历，需理解它的处理逻辑：for---横向处理，递归---纵向处理

        # 存放结果的二维数组
        res = []

        self.backStacking(n,k,1,[],res)

        return res