24.2.7总结 回溯

目录

什么是回溯法

回溯法解决的问题

如何理解回溯法

回溯法

组合

组合3（不可重复使用）

组合4（可重复使用）

---

什么是回溯法

回溯法也可以叫做回溯搜索法，它是一种搜索的方式。

回溯法解决的问题

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

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

如何理解回溯法

回溯法解决的问题都可以抽象为树形结构

回溯法

• 递归函数的返回值以及参数
• 回溯搜索的遍历过程
• 回溯函数终止条件

回溯函数终止条件伪代码如下：

if (终止条件) {

    存放结果;

    return;
}

回溯函数遍历过程伪代码如下：

for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
    处理节点;

    backtracking(路径，选择列表); // 递归

    回溯，撤销处理结果
}

组合

一般想到的直接解法运用两层for循环

k=2;

for（int i=1;i<=n;i++）{

    for（int j=i+1;j<=n;j++）{

   printf("%d %d\n",i,j);
   

    }



}

但当k太大时 明显for循环不可行了   因此可以尝试运用回溯算法

要解决 n为100，k为50的情况，暴力写法需要嵌套50层for循环，那么回溯法就用递归来解决嵌套层数的问题。每一次的递归中嵌套一个for循环，那么递归就可以用于解决多层嵌套循环的问题了。

#include<bits/stdc++.h>
using namespace std;
int a[100];
int r,n;
void dfs(int k) 
{
	
	if(k>r){
	 	for(int i=1;i<=r;i++){
	 		printf("%d",a[i]);
		 }
		 printf("\n");
		 return ;
	} //终止条件
	for(int i=a[k-1]+1;i<=n;i++)//横向遍历
{
		a[k]=i;
	   dfs(k+1);
	}
	 
}
int main(){
	cin>>n>>r;
	
		dfs(1);
	
}

vector<vector<int>> result; // 存放符合条件结果的集合

    vector<int> path; // 用来存放符合条件结果

    void backtracking(int n, int k, int startIndex) //startInde为当前选的数
{

        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(); // 回溯，撤销处理的节点
        }
    }

    vector<vector<int>> combine(int n, int k) {

        result.clear(); // 可以不写

        path.clear();   // 可以不写

        backtracking(n, k, 1);
        return result;
    

组合3（不可重复使用）

本题 k（选k个数）相当于树的深度，9（因为整个集合就是9个数）就是树的宽度。

选定好参数：目标和（targetsum）   当前和   (sum)   下一层for循环搜索的起始位置（startIndx）

选取的数的个数（k）

确定终止条件：达到k个时就终止  如果总和为targetsum ，那么就可以输出结果

vector<vector<int>> result; // 存放结果集
    vector<int> path; // 符合条件的结果
    // targetSum：目标和，也就是题目中的n。
    // k：题目中要求k个数的集合。
    // sum：已经收集的元素的总和，也就是path里元素的总和。
    // startIndex：下一层for循环搜索的起始位置。
    void backtracking(int targetSum, int k, int sum, int startIndex) {
        if (path.size() == k) {
            if (sum == targetSum) result.push_back(path);
            return; // 如果path.size() == k 但sum != targetSum 直接返回
        }
        for (int i = startIndex; i <= 9; i++) {
            sum += i; // 处理
            path.push_back(i); // 处理
            backtracking(targetSum, k, sum, i + 1); // 注意i+1调整startIndex
            sum -= i; // 回溯
            path.pop_back(); // 回溯//pop的是递归之后的数 递归前加入的不用pop出去
        }
    }

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

组合4（可重复使用）

因为元素的选用没有次数要求，所以递归没有层数的限制，只有当sum>target时才会停止递归返回

 vector<vector<int>> result;
    vector<int> path;

    void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
        if (sum > target) {
            return;//大于就该返回了
        }
        if (sum == target) {
            result.push_back(path);
            return;
        }

        for (int i = startIndex; i < candidates.size(); i++) {
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i); // 不用i+1了，表示可以重复读取当前的数
            sum -= candidates[i];
            path.pop_back();
        }
    }
public:
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        result.clear();
        path.clear();
        backtracking(candidates, target, 0, 0);
        return result;
    }