回溯法
回溯法也可以叫做回溯搜索法，它是一种搜索的方式。
回溯是递归的副产品，只要有递归就会有回溯。
然回溯法很难，很不好理解，但是回溯法并不是什么高效的算法。因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法高效一些，可以加一些剪枝的操作，但也改不了回溯法就是穷举的本质。
那么既然回溯法并不高效为什么还要用它呢？
因为没得选，一些问题能暴力搜出来就不错了，撑死了再剪枝一下，还没有更高效的解法。
回溯法解决的问题
回溯法，一般可以解决如下几种问题：
- 组合问题：N个数里面按一定规则找出k个数的集合
- 切割问题：一个字符串按一定规则有几种切割方式
- 子集问题：一个N个数的集合里有多少符合条件的子集
- 排列问题：N个数按一定规则全排列，有几种排列方式
- 棋盘问题：N皇后，解数独等等
如何理解回溯法
回溯法解决的问题都可以抽象为树形结构，是的，我指的是所有回溯法的问题都可以抽象为树形结构！
因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度就构成了树的深度。
递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。
回溯法模板
- 回溯函数模板返回值以及参数
回溯函数伪代码如下：
void backtracking(参数)- 回溯函数终止条件
所以回溯函数终止条件伪代码如下：
if (终止条件) {
存放结果;
return;
}- 回溯搜索的遍历过程
回溯函数遍历过程伪代码如下：
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}for循环就是遍历集合区间，可以理解一个节点有多少个孩子，这个for循环就执行多少次。
backtracking这里自己调用自己，实现递归。
可以从图中看出for循环可以理解是横向遍历，backtracking（递归）就是纵向遍历，这样就把这棵树全遍历完了，一般来说，搜索叶子节点就是找的其中一个结果了。
分析完过程，回溯算法模板框架如下：
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
第77题. 组合
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;
}
};- 时间复杂度: O(n * 2^n)
- 空间复杂度: O(n)
剪枝优化
可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。
如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。
接下来看一下优化过程如下：
-
已经选择的元素个数：path.size();
-
所需需要的元素个数为: k - path.size();
-
列表中剩余元素（n-i） >= 所需需要的元素个数（k - path.size()）
-
在集合n中至多要从该起始位置 : i <= n - (k - path.size()) + 1，开始遍历
所以优化之后的for循环是：
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++) // i为本次搜索的起始位置优化后整体代码如下：
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 - (k - path.size()) + 1; i++) { // 优化的地方
path.push_back(i); // 处理节点
backtracking(n, k, i + 1);
path.pop_back(); // 回溯，撤销处理的节点
}
}
public:
vector<vector<int>> combine(int n, int k) {
backtracking(n, k, 1);
return result;
}
};- 时间复杂度: O(n * 2^n)
- 空间复杂度: O(n)
何时会出现 O(n * 2^n) 的时间复杂度？
时间复杂度是衡量算法在输入规模增加时，执行时间增长速度的指标。为了计算时间复杂度，需要估算算法的关键操作（如循环、递归调用等）执行的次数。
这种复杂度通常出现在子集生成或组合问题中，特别是当你需要生成某个集合的所有子集时。
生成所有子集的算法分析
- 假设我们有一个长度为
n的集合，例如{1, 2, 3, ..., n}。 - 每个元素可以有两种状态：要么包含在子集中，要么不包含在子集中。因此，对于每个元素，我们有两种选择，这导致子集总数为
2^n。 - 因为我们要生成
2^n个子集，每个子集平均包含n个元素中的一些元素，所以时间复杂度可以估计为每个子集操作O(n)，总的时间复杂度为O(n * 2^n)。
空间复杂度
空间复杂度是衡量算法在执行过程中所需的额外空间。通常包括递归调用栈的空间以及临时变量的空间。
path 临时变量的空间
- 在回溯过程中，
path用于存储当前正在处理的子集，path的最大长度为n，因为你在每次递归调用时最多会选择n个元素。 - 因此，
path所占的空间最多为O(n)，因为它在递归过程中的深度最多是n。
空间复杂度的完整分析
在回溯算法中，空间复杂度主要有以下两部分：
-
递归调用栈的空间：递归深度最大为
n，因此递归调用栈的空间复杂度是O(n)。 -
path临时变量的空间：path用于存储当前子集，最大长度为n，因此其空间复杂度也是O(n)。
这两个部分是额外的空间，而结果集的存储空间（即存储所有子集）是算法的输出空间，通常不计入空间复杂度分析。
总的空间复杂度
- 递归调用栈空间：
O(n)。 path临时变量空间：O(n)。
因此，额外空间复杂度 是 O(n)，因为递归调用栈和 path 的空间都为 O(n)。
结果存储空间（输出空间）
对于给定的 n 个元素，子集问题会生成所有可能的子集，总共会有 2^n 个子集。因为每个元素都有两种状态：要么包含在子集中，要么不包含在子集中。
- 生成的子集数量是
2^n。 - 每个子集的大小从 0 到
n不等，因此存储所有子集的总空间为O(2^n)。
结论
- 额外空间复杂度（递归调用栈和
path临时变量）：O(n)。 - 结果存储空间：
O(2^n)（用于存储所有子集）。
216.组合总和III
class Solution {
private:
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(); // 回溯
}
}
public:
vector<vector<int>> combinationSum3(int k, int n) {
result.clear(); // 可以不加
path.clear(); // 可以不加
backtracking(n, k, 0, 1);
return result;
}
};剪枝优化
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;
}
};17.电话号码的字母组合
class Solution {
private:
const string letterMap[10] = {
"", // 0
"", // 1
"abc", // 2
"def", // 3
"ghi", // 4
"jkl", // 5
"mno", // 6
"pqrs", // 7
"tuv", // 8
"wxyz", // 9
};
public:
vector<string> result;
string s;
void backtracking(const string& digits, int index) {
if (index == digits.size()) {
result.push_back(s);
return;
}
int digit = digits[index] - '0'; // 将index指向的数字转为int
string letters = letterMap[digit]; // 取数字对应的字符集
for (int i = 0; i < letters.size(); i++) {
s.push_back(letters[i]); // 处理
backtracking(digits, index + 1); // 递归，注意index+1，一下层要处理下一个数字了
s.pop_back(); // 回溯
}
}
vector<string> letterCombinations(string digits) {
s.clear();
result.clear();
if (digits.size() == 0) {
return result;
}
backtracking(digits, 0);
return result;
}
};因为 '0' 到 '9' 在 ASCII 编码表中占据了连续的十个值，分别是从 48 到 57。这些字符与整数的映射是直接的，它们通过减去 '0' 可以得到对应的整数值。
ASCII 编码表包含了 128 个字符，其码值范围从 0 到 127。这个范围包括了控制字符、数字、字母、标点符号等。
输入为空字符串时，不应该有任何递归操作，直接返回空的 result，即 []。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
