回溯算法理论基础及组合问题-代码随想录

理论基础：

1.只要有递归就会有回溯，回溯搜索法也是一种暴力的穷举可能的解法。

2.回溯的本质是在一个for循环里递归，（也可以理解为在递归里for循环），总之是一个for循环+递归。

3.根据回溯法的本质，可以将其理解为一个树形结构。如下图所示。

 可以看出回溯最终要返回的值（也就是我们要找的值），就是多叉树的叶子节点。

回溯法解决的问题

回溯法，一般可以解决如下几种问题：

• 组合问题：N个数里面按一定规则找出k个数的集合
• 切割问题：一个字符串按一定规则有几种切割方式
• 子集问题：一个N个数的集合里有多少符合条件的子集
• 排列问题：N个数按一定规则全排列，有几种排列方式（排列和组合的区别为组合无序，排列有序）
• 棋盘问题：N皇后，解数独等等

回溯法的思路及模板：

回溯法也是递归函数，因此在使用时也有三部曲：

1.返回值及参数；(void没有返回值，不要忘记return)

2.终止条件

3.递归遍历逻辑（一定有for循环）

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

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

第77题. 组合

力扣题目链接(opens new window)

给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。

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

class Solution {
private:
    vector<vector<int>> result; // 存放符合条件结果的集合
    vector<int> path; // 用来存放符合条件结果
    void backtracking(int n, int k, int startIndex) {
        if (path.size() == k) {
            result.push_back(path);
            return;
        }
        for (int i = startIndex; i <= n; i++) {
            path.push_back(i); // 处理节点
            backtracking(n, k, i + 1); // 递归
            path.pop_back(); // 回溯，撤销处理的节点
        }
    }
public:
    vector<vector<int>> combine(int n, int k) {
        result.clear(); // 可以不写
        path.clear();   // 可以不写
        backtracking(n, k, 1);
        return result;
    }
};

对比模板可以得出代码注意点：

1.result的返回值为二维数组

2.在for循环中需要定义一个startindex，来定义不同递归层数的开始位置。

3.path.pop即为回溯（撤销）的过程

java：

class Solution {
    List<List<Integer>> result = new ArrayList<>();
    LinkedList<Integer> path = new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        combineHelper(n, k, 1);
        return result;
    }

    /**
     * 每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围，就是要靠startIndex
     * @param startIndex 用来记录本层递归的中，集合从哪里开始遍历（集合就是[1,...,n] ）。
     */
    private void combineHelper(int n, int k, int startIndex){
        //终止条件
        if (path.size() == k){
            result.add(new ArrayList<>(path));
            return;
        }
        for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){
            path.add(i);
            combineHelper(n, k, i + 1);
            path.removeLast();
        }
    }
}

组合优化（剪枝）

假设上题中元素为n=4，k=4；可以进行剪枝优化：

即：不去递归有深度的且不符合条件的分支

注意：1.根据回溯的基础，可以看出是横向的减少，即for循环的减少，因此剪枝操作主要考虑减少for循环的区间

           2.上题中for循环的区间为o~n，优化过程为：

1. 已经选择的元素个数：path.size();

2. 所需需要的元素个数为: k - path.size();

3. 列表中剩余元素（n-i） >= 所需需要的元素个数（k - path.size()）

4. 在集合n中至多要从该起始位置 : i <= n - (k - path.size()) + 1，开始遍历

为什么有个+1呢，因为包括起始位置，我们要是一个左闭的集合

       

for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) // i为本次搜索的起始位置