code freethinking--回溯算法 * 重点笔记 *核心代码*

基础了解：

回溯搜索法（回溯法），和递归方法相伴而生，只要有回溯就有递归

回溯法的本质是穷举，优化只是加一些剪枝。

主要解决的问题：

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

回顾：递归三部曲：确定函数的参数和返回值，确定终止条件，单层递归逻辑。

回溯三部曲：回溯函数模板的参数和返回值，确定终止条件，单层回溯搜索过程。

回溯和递归是相辅相成的，模板先记好，接下来学习运用

回溯法，横向for循环，纵向递归

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

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

组合问题

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

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

回溯函数的参数和返回值

题目中说是两个整数n和k，我们可以从树形结构进行理解，n就类似于树的横向结构，K则明显决定了纵向深度，又因为是组合，所以确定从某个数开始之后不需要往回走，只需要往后进行组合就可以，因此需要一个startIndex参数，另外我们可以定义两个全局变量来存放结果：

一个是存放符合条件的单一结果，vector<int>path

一个是所有符合结果的集合，vector<vector<int >>result

void Backtracing(int n,int k,int startIndex)

终止条件

当path达到了k的深度时候，就确定千万个中的一个组合。此时用result把path保存起来，并终止本层递归

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); // 递归：控制树的纵向遍历，注意下一层搜索要从i+1开始
    path.pop_back(); // 回溯，撤销处理的节点
}

backtracking（递归函数）通过不断调用自己一直往深处遍历，总会遇到叶子节点，遇到了叶子节点就要返回。

• 时间复杂度: O(n * 2^n)
• 空间复杂度: O(n)

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        backtracing(n,k,1);
        return result;
    }

private:
    vector<vector<int>> result;
    vector<int> single;
    void backtracing(int n,int k,int startIndex){
        if(single.size() == k){
        result.push_back(single);
        return;
    }
    for(int i = startIndex;i<=n;i++){
        single.push_back(i);
        backtracing(n,k,i+1);
        single.pop_back();
    }

    }
};

优化策略

核心就是剪枝，如果for循环选择的起始位置之后的元素个数“小于”我们需要的元素个数，那么就是无效搜索，可以剪枝去了。

class Solution {
public:
    vector<vector<int>> combine(int n, int k) {
        backtracing(n,k,1);
        return result;
    }

private:
    vector<vector<int>> result;
    vector<int> single;
    void backtracing(int n,int k,int startIndex){
        if(single.size() == k){
        result.push_back(single);
        return;
    }
    for(int i = startIndex;i<=n-(k-path.size())+1;i++){
//剪枝就是在这加了一个判断
        single.push_back(i);
        backtracing(n,k,i+1);
        single.pop_back();
        }
    }
};

---

找出所有相加之和为 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相当于树的深度，n相当于树的宽度，而n又限定好了集合范围是[1,9]，简单

还是三部曲思考，确定回溯函数的参数和返回值，因为判断的是相等，所以要加两个sum的参数

确定返回值，当path.sum == targetsum 时

单层搜索过程

sum统计元素总和，记得回溯要减去

剪枝也很好理解

class Solution {
private:
    vector<vector<int>> result; // 存放结果集
    vector<int> path; // 符合条件的结果
    void backtracking(int targetSum, int k, int sum, int startIndex) {
        if (sum > targetSum) { // 剪枝操作
            return; 
        }
        if (path.size() == k) {
            if (sum == targetSum) result.push_back(path);
            return; // 如果path.size() == k 但sum != targetSum 直接返回
        }
        for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) { // 剪枝
            sum += i; // 处理
            path.push_back(i); // 处理
            backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
            sum -= i; // 回溯
            path.pop_back(); // 回溯
        }
    }

public:
    vector<vector<int>> combinationSum3(int k, int n) {
        result.clear(); // 可以不加
        path.clear();   // 可以不加
        backtracking(n, k, 0, 1);
        return result;
    }
};

分割

排列

棋盘问题

其他