【笔记】回溯问题总结 2.0
我刷题两天，总结出回溯法解题的玄机…
个人心得
本部分参考自：代码随想录 - 回溯法总结篇
问题本质
回溯是递归的副产品，常与深度优先搜索、二叉树遍历一起出现。本质是暴力搜索算法（最多剪枝优化），只不过是用递归的方式控制了for循环嵌套的数量，即：for循环横向遍历，递归纵深遍历，回溯不断调整结果集。将遍历过程抽象为树的结构可以更好地理解。
与树的前中后序遍历相同的是，回溯过程也有收集结果的三个不同位置，在终止递归的if()条件前、在终止递归的if()条件中【最常见】、在for()循环结束后，对应收集到的是全部节点、叶子节点、非叶子节点。
解题步骤
“Carl回溯三部曲”（和树的递归三部曲一样）
-
回溯函数backtracking模板的返回值及其参数
-
回溯函数的终止条件
-
回溯搜索的遍历过程
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 向深处递归
回溯，撤销处理结果，即处理节点的逆操作；
}
}
一些说明
1、单个集合，求组合时需要设置startIndex，多个集合求组合，不需要设置startIndex
2、for中向下一层递归的backtracking()参数，元素允许重复使用可从i开始，若限制次数必须往后i + 1
3、每层遍历时，求组合时for当中int i = startIndex，下一次回溯调用从i + 1开始，否则求排列时一般从i = 0开始
4、注意求组合时的剪枝操作，树干剪枝和树层剪枝。层次去重时，要使用 原数组排序+used数组 记录元素是否被访问，尽量不使用unordered_map去重，时间复杂度太高
5、backtracking()函数的返回值一般是void，何时为bool？因为解数独找到一个符合的条件（就在树的叶子节点上）立刻就返回，相当于找从根节点到叶子节点一条唯一路径，所以需要使用bool返回值，这一点在 重新安排行程、回溯算法：N皇后问题 中已经介绍过了，一样的道理。
6、注意返回条件和收集result的位置关系，三种情况
适用场景
回溯算法能解决如下问题：
- 组合问题：N个数里面按一定规则找出k个数的集合，在求和问题中，排序之后加剪枝是常见的套路！
- 排列问题：N个数按一定规则全排列，有几种排列方式
- 切割问题：一个字符串按一定规则有几种切割方式
- 子集问题：一个N个数的集合里有多少符合条件的子集
- 棋盘问题：N皇后，解数独等等
收集所有叶子节点
组合问题
-
77. 组合 - 力扣（LeetCode），给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
回溯法的魅力，避免k个数写k层for循环，用递归控制for循环嵌套的数量
剪枝优化，组合不考虑排列顺序，因此for从i = startIndex开始遍历，剪枝时，i <= n - (k - path.size()) + 1
// path.size()已经选择的元素个数
// k - path.size()还需选择的元素个数
// 在集合n中至多要从该起始位置 : n - (k - path.size()) + 1，开始遍历，才能够数，之后开始的位置都需要剪枝
class Solution {
private:
// 全局变量，存放子集和最终结果集
vector<int> vec;
vector<vector<int>> result;
public:
vector<vector<int>> combine(int n, int k) {
if (n == 1) return {{1}};
backtracking(n, k, 1);
return result;
}
void backtracking(int n, int k, int startIndex) {
if (vec.size() == k) {
result.push_back(vec);
return;
}
// 剪枝优化
// for 控制了每层循环的起始位置
// 假设n = 4个数挑3个出来，当从3或4开始是无效的，因为此时开始已经不够3个数，可以剪枝
// 子集合中已有元素个数是vec.size()，还需k - vec.size()
// 在总集合n中 至多 要从起始位置n - (k - vec.size()) + 1 开始遍历，才能够数
// i如果超过该位置，一定不够数，此时可以剪枝
for (int i = startIndex; i <= n - (k - vec.size()) + 1; i++) {
vec.push_back(i);
backtracking(n, k, i + 1);
vec.pop_back();
}
}
};
- 216. 组合总和 III - 力扣（LeetCode），找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。比第一题多了总和的限制。照旧，从i = startIndex开始遍历，可以有i <= 9 - (k - path.size()) + 1剪枝和总和超过sum就return 两种剪枝
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
public:
vector<vector<int>> combinationSum3(int k, int n) {
backtracking(k, n, 1);
return result;
}
// k就是题目中要求k个数的集合
// targetSum目标和，初始值就是题目中的n，后面会递减
// startIndex为下一层for循环搜索的起始位置
void backtracking(int k, int targetSum, int startIndex) {
// 双剪枝之一，超过目标和直接return
if (targetSum < 0) {
return;
}
if (k == path.size()) {
if (targetSum == 0) result.push_back(path);
return;
}
// 双剪枝之二，遍历到刚好凑不够i个数位置即可
for (int i = startIndex; i <= 9 - (k - path.size()) + 1; i++) {
targetSum -= i;
path.push_back(i);
backtracking(k, targetSum, i + 1);
path.pop_back();
targetSum += i;
}
}
};
- 39. 组合总和 - 力扣（LeetCode），1、比第二题少了限制，不限制每个元素只能选一次，因此递归backtracking部分不用i + 1，直接i开始下一层递归2、for中进行剪枝避免进入下一层递归，如果只在开始处进行判断，实际上已经进入了下一层递归并且在结束判断，3、最好先对候选数组排序
class Solution {
private:
vector<int> path;
vector<vector<int>> result;
public:
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
// 先排序才能更好的剪枝
sort(candidates.begin(), candidates.end());
backtracking(candidates, target, 0);
return result;
}
// 不加index求的是排列
void backtracking(const vector<int>& candidates, int target, int startIndex) {
// 对于sum已经大于target的情况，这种写法其实是依然进入了下一层递归
// 只是下一层递归结束判断的时候，会判断sum > target的话就返回
// 但其实如果已经知道下一层的sum会大于target，就没有必要进入下一层递归了
// 那么可以在for循环的搜索范围上做做文章了
/*
if (target < 0) {
return;
}
*/
if (target == 0) {
result.push_back(path);
return;
}
// 求排列，每个for从startIndex开始遍历
// 剪枝
for (int i = startIndex; i < candidates.size() && target - candidates[i] >= 0; i++) {
target -= candidates[i];
path.push_back(candidates[i]);
// 由于可以重复，因此下一层for不需要i + 1，直接再从本位置i开始即可
backtracking(candidates, target, i);
path.pop_back();
target += candidates[i];
}
}
};
-
【有难度】难在去重。这里需要采用“层次去重”，最好先排序，然后引入used数组记录元素是否被访问过
candidates[i] == candidates[i - 1] && used[i - 1] == false，代表同一树层重复了，因为false只能是通过回溯得来的，应跳过
candidates[i] == candidates[i - 1] && used[i - 1] == true，代表同一树枝的上层节点刚使用过，合法
图示如下：
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
public:
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
// 本题要求每个数字在每个组合中只能使用一次
// 元素在同一个组合内（同一树枝）是可以重复的，怎么重复都没事，但两个组合不能相同，所以是树层去重
// 假设[1,1,2]，target = 3，取第一个1情况下，已经构成子集[1, 2]，下一次遍历就不能用第二个1了
// 因此引入uesd数组去重
vector<bool> used(candidates.size(), false);
sort(candidates.begin(), candidates.end());
backtracking(candidates, target, 0, used);
return result;
}
void backtracking(const vector<int>& candidates, int target, int startIndex, vector<bool>& used) {
if (target == 0) {
result.push_back(path);
return;
}
for (int i = startIndex; i < candidates.size() && target - candidates[i] >= 0; i++) {
// used[i - 1] == true，说明同一树枝candidates[i - 1]使用过，允许
// used[i - 1] == true，一直往下递归，还未回溯
// used[i - 1] == false，说明同一树层(上一根不同的树枝)candidates[i - 1]使用过，直接进入下一循环
// used[i - 1] == false说明used[i]是回溯得来，需要去重
// 要对同一树层使用过的元素进行跳过
if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
continue;
}
target -= candidates[i];
path.push_back(candidates[i]);
used[i] = true;
backtracking(candidates, target, i + 1, used);
used[i] = false;
path.pop_back();
target += candidates[i];
}
}
};
多个集合求组和
- 17. 电话号码的字母组合 - 力扣（LeetCode），注意这里for循环可不是从startIndex开始遍历的，因为本题每一个数字代表的是不同集合，也就是求不同集合之间的组合。而且index也不同与以往的startIndex，是记录遍历第几个数字了，就是用来遍历digits的（题目中给出数字字符串），同时index也表示树的深度
注意：输入1 * #按键等等异常情况
代码中最好考虑这些异常情况，但题目的测试数据中应该没有异常情况的数据，所以我就没有加了。
但是要知道会有这些异常，如果是现场面试中，一定要考虑到！
class Solution {
private:
vector<string> result;
string s;
const string lettermap[10] = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
public:
vector<string> letterCombinations(string digits) {
if (digits.size() == 0) return {};
backtracking(digits, 0);
return result;
}
// 1、如何把字母和数字对应起来？构建lettermap，把string格式的数字转化为下标int，在lettermap中取得对应的字符集
// 2、index是什么？当前遍历到的数字下标
// 3、输入1、*、# 等异常案按键情况处理
void backtracking(string digits, int index) {
if (index == digits.size()) {
result.push_back(s);
return;
}
int digit = digits[index] - '0'; // char和int的转换
string letters = lettermap[digit];
for (int i = 0; i < letters.size() ; i++) {
s.push_back(letters[i]);
backtracking(digits, index + 1);
s.pop_back();
}
}
};
切割问题（用求解组合的思路来解决）
有如下几个难点(以分割回文串为例)：
- 切割问题其实类似组合问题
- 如何模拟那些切割线，用startIndex模拟
- 切割问题中递归如何终止，startIndex >= s.size() 时，即可认为超过上限
- 在递归循环中如何截取子串，用substr(pos, len)函数
- 如何判断回文，双指针
class Solution {
private:
vector<vector<string>> result;
vector<string> path;
public:
bool check(string s) {
for (int i = 0, j = s.size() - 1; i < j; i++, j--) {
if (s[i] != s[j])
return false;
}
return true;
}
void backtracking(string s, int startIndex) {
// 何时返回，下标超过字符串string即可认为结束
if (startIndex == s.size()) {
result.push_back(path);
return;
}
for (int i = startIndex; i < s.size(); i++) {
// 怎么切割，用substr函数
string temp = s.substr(startIndex, i - startIndex + 1);
if (check(temp))
path.push_back(temp);
else
continue;
backtracking(s, i + 1);
path.pop_back();
}
}
vector<vector<string>> partition(string s) {
if (s.size() == 1) return {{s}};
backtracking(s, 0);
return result;
}
};
二刷。1、关于check代码部分写的磕磕绊绊；2、回溯的返回条件看pointNum数量；3、返回值是string，因此是直接往源字符串中加点，最后满足条件把整个带点的字符串返回
131要求返回若干回文串，本题限制返回4个IP字符串
class Solution {
private:
vector<string> result;
public:
vector<string> restoreIpAddresses(string s) {
if (s.size() < 4 || s.size() > 12) return {};
backtracking(s, 0, 0);
return result;
}
// 多添加一个记录逗点数量的参数
void backtracking(string& s, int startIndex, int pointNum) {
// 本题明确要求只会分成4段，所以不能用切割线切到最后作为终止条件，而是分割的段数作为终止条件
// pointNum为3说明字符串分成了4段了,然后验证一下第四段是否合法，如果合法就加入到结果集里
if (pointNum == 3) {
if (check(s, startIndex, s.size() - 1))
result.push_back(s);
return;
}
for (int i = startIndex; i < s.size() ; i++) {
if (check(s, startIndex, i)) {
s.insert(s.begin() + i + 1, '.');
pointNum++;
backtracking(s, i + 2, pointNum);
pointNum--;
s.erase(s.begin() + i + 1);
}
else
continue;
}
}
bool check(const string& s, int start, int end) {
if (start > end) return false;
// 不能有前导0
if (s[start] == '0' && start != end) return false;
// string转化为int，用atoi
string temp = s.substr(start, end - start + 1);
int num = atoi(temp.c_str());
if (num > 255 || num < 0) return false;
return true;
}
};
收集树的所有节点
子集问题
- 78. 子集 - 力扣（LeetCode），**组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点，**注意收集result是所有节点，因此该语句要放在终止条件的上面
【自己研究】注意三种收集信息的位置，对应了三种不同的情况，感觉和树的前中后序遍历有点像
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
public:
vector<vector<int>> subsets(vector<int>& nums) {
backtracking(nums, 0);
return result;
}
void backtracking(vector<int>& nums, int startIndex) {
// 合法的节点都是子集，收集子集要放在终止添加的上面，否则会漏掉自己
// 1、收集所有节点的位置
result.push_back(path);
// 其实可以不需要加终止条件，因为startIndex >= nums.size()，本层for循环本来也结束了
if (startIndex >= nums.size()) {
// 2、收集所有叶子节点的位置
return;
}
// 不需要剪枝，因为子集就是要遍历整个树
for (int i = startIndex; i < nums.size(); i++) {
path.push_back(nums[i]);
backtracking(nums, i + 1); // 若是叶子节点，这一步已经结束循环，无孩子可回溯
path.pop_back(); // 回溯
}
// 3、收集所有非叶子节点的位置
// 能执行到这一步，说明for整个被执行完，其中回溯也是执行了，说明结果是（从其孩子节点）回溯得来的，因此必定不是叶子节点
}
};
- 90. 子集 II - 力扣（LeetCode），子集去重，有 uesd布尔数组法 和 unordered_set法，考虑到时空复杂度建议用前者。一定要先排序！和组合问题中的去重逻辑一致，用层次去重法秒杀。
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
public:
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
vector<bool> used(nums.size(), false);
sort(nums.begin(), nums.end());
backtracking(nums, 0, used);
return result;
}
void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
result.push_back(path);
if (startIndex >= nums.size()) {
return;
}
for (int i = startIndex; i < nums.size(); i++) {
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
continue;
}
path.push_back(nums[i]);
used[i] = true;
backtracking(nums, i + 1, used);
used[i] = false;
path.pop_back();
}
}
};
- 491. 递增子序列 - 力扣（LeetCode），很像子集问题，但是一定不能排序，因为原始的子序列与下标有关。因此去重的逻辑需要改变，不能用sort+used数组去重，需要使用 unordered_set法 去重
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
public:
vector<vector<int>> findSubsequences(vector<int>& nums) {
if (nums.size() < 2) return {};
backracking(nums, 0);
return result;
}
void backracking(vector<int>& nums, int startIndex) {
if (path.size() > 1) {
result.push_back(path);
// 注意这里不要加return，因为要取树上的所有节点
}
// 下标不能动，不能用sort+used数组去重，需要使用set去重
unordered_set<int> set;
for (int i = startIndex; i < nums.size(); i++) {
// 所取元素小于子序列最后一个元素（不满足递增），或者同一层使用过
if (!path.empty() && nums[i] < path.back() || set.find(nums[i]) != set.end()) {
continue;
}
set.insert(nums[i]);
path.push_back(nums[i]);
backracking(nums, i + 1);
path.pop_back();
// set是记录本层元素是否重复使用，新的一层set都会重新定义（清空），所以set只负责本层for
// 因此set不需要弹出
}
}
};
收集所有叶子节点
排列问题
- 46. 全排列 - 力扣（LeetCode），收集所有的叶子节点，每层都是从0开始搜索而不是startIndex，需要used数组记录path里都放了哪些元素
排列问题和组合问题的不同：
- 每层都是从0开始搜索而不是startIndex
- 需要used数组记录path里都放了哪些元素了
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
public:
vector<vector<int>> permute(vector<int>& nums) {
if (nums.size() == 1) return{{nums[0]}};
vector<bool> used(nums.size(), false);
backtracking(nums, used);
return result;
}
// 求排列不需要startIndex，但需要used
void backtracking(vector<int>& nums, vector<bool>& used) {
if (path.size() == nums.size()) {
result.push_back(path);
return;
}
// 每层都是从0开始搜索而不是startIndex
for (int i = 0; i < nums.size(); i++) {
// used数组记录此时path里都有哪些元素使用了，一个排列里一个元素只能使用一次
// path里已经收录的元素，直接跳过
if (used[i] == true) continue;
path.push_back(nums[i]);
used[i] = true;
backtracking(nums, used);
path.pop_back();
used[i] = false;
}
}
};
- 47. 全排列 II - 力扣（LeetCode），去重版全排列，【神奇的是】，本题排序+树层和树枝used布尔数组去重都可以，但是画图展开后发现，树层去重要比树枝去重的效率更高，少做了很多无用搜索。出于效率原因，不建议使用set法，当然这么做也是可以的。
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
public:
vector<vector<int>> permuteUnique(vector<int>& nums) {
if (nums.size() == 1) return {{nums[0]}};
vector<bool> used(nums.size(), false);
sort(nums.begin(), nums.end());
backtracking(nums, used);
return result;
}
void backtracking(vector<int>& nums, vector<bool>& used) {
if (path.size() == nums.size()) {
result.push_back(path);
return;
}
for (int i = 0; i < nums.size(); i++) {
// 去重1，树层去重，本题的特殊要求
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
continue;
}
// 去重2，path里已经收录的元素，直接跳过，这是全排列基础模板所要求
if (used[i] == true) {
continue;
}
path.push_back(nums[i]);
used[i] = true;
backtracking(nums, used);
used[i] = false;
path.pop_back();
}
}
};
重新安排行程
- 332. 重新安排行程 - 力扣（LeetCode），难！难在容器的选择和使用，backtracking函数返回值为bool，因为找到即可返回，不需要遍历整个树
这道题目有几个难点：
- 一个行程中，如果航班处理不好容易变成一个圈，成为死循环。因此要及时删除已经遍历过的
- 有多种解法，字母序靠前排在前面，让很多同学望而退步，如何该记录映射关系呢 ？用map，map底层红黑树，会按照string升序排列
- 使用回溯法（也可以说深搜）的话，那么终止条件是什么呢？n个机票连接n+1个机场
- 搜索的过程中，如何遍历一个机场所对应的所有机场。用该数据结构，unordered_map<出发机场, map<到达机场, 航班次数>> targets
class Solution {
private:
vector<string> result;
// 出发机场和到达机场是会重复的，搜索的过程没及时删除目的机场就会死循环
// 本题既要找到一个对string进行排序的容器（map），而且还要容易增删元素，迭代器还不能失效
// unordered_map<出发机场, map<到达机场, 航班次数>> targets，用标记数量加减代替删除操作，并非是真正的删除
unordered_map<string, map<string, int>> targets;
public:
vector<string> findItinerary(vector<vector<string>>& tickets) {
// 初始化
result.push_back("JFK");
for (auto ticket : tickets) {
targets[ticket[0]][ticket[1]]++;
}
backtracking(tickets.size(), result);
return result;
}
// 找到一个合理的行程即返回
bool backtracking(int ticketNum, vector<string>& result) {
if (result.size() == ticketNum + 1) {
return true;
}
// 以结果集中最后一个机场为起点，看还有哪些地方可以飞到
// 若写auto会出错，返回结果不是排序最小的，原因是没加&，没用修改到计数
for (pair<const string, int>& target : targets[result.back()]) {
cout << typeid(target).name() << '\n';
// 还可以飞
if (target.second > 0) {
result.push_back(target.first);
target.second--;
// 判断是否能继续飞
if (backtracking(ticketNum, result))
return true;
target.second++;
result.pop_back();
}
}
return false;
}
};
棋盘问题
- 51. N 皇后 - 力扣（LeetCode），棋盘的宽度就是for循环的长度，递归的深度就是棋盘的高度，这样就可以套进回溯法模板
递归深度就是row控制棋盘的行，每一层里for循环的col控制棋盘的列，一行一列，确定了放置皇后的位置。
每次都是要从新的一行的起始位置开始搜，所以都是从0开始。
class Solution {
private:
vector<vector<string>> result;
public:
vector<vector<string>> solveNQueens(int n) {
// 初始化棋盘
vector<string> chessboard(n, string(n, '.'));
backtracking(n, 0, chessboard);
return result;
}
void backtracking(int n, int row, vector<string>& chessboard) {
// 回溯树的高度和宽度都是n，到达叶子节点返回
if (row == n) {
result.push_back(chessboard);
return;
}
for (int col = 0; col < n; col++) {
if (check(row, col, chessboard, n)) {
chessboard[row][col] = 'Q';
backtracking(n, row + 1, chessboard);
chessboard[row][col] = '.';
}
}
}
bool check(int row, int col, vector<string>& chessboard, int n) {
// 每层取一个Q，不需要检查行
// 检查列
for (int i = 0; i < row; i++) {
if (chessboard[i][col] == 'Q')
return false;
}
// 只需要检查左上方45度角，不用检查右下方是因为下面还没放，Q肯定是空棋盘
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
if (chessboard[i][j] == 'Q')
return false;
}
// 只需要检查右上方135度角
for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
if (chessboard[i][j] == 'Q')
return false;
}
return true;
}
};
- 52. N 皇后 II - 力扣（LeetCode），51是返回符合要求的棋盘。本题是返回棋盘个数，如果没有51题的铺垫，会更难一点。
class Solution {
private:
vector<vector<string>> result;
public:
int totalNQueens(int n) {
vector<string> chessboard(n, string(n, '.'));
backtracking(chessboard, n, 0);
return result.size();
}
void backtracking(vector<string>& chessboard, int depth, int row) {
if (depth == row) {
result.push_back(chessboard);
return;
}
for (int col = 0; col < chessboard.size(); col++) {
if (check(row, col, depth, chessboard)) {
chessboard[row][col] = 'Q';
backtracking(chessboard, depth, row + 1);
chessboard[row][col] = '.';
}
}
}
bool check(int row, int col, int depth, vector<string>& chessboard) {
// 行不用检查，检查列
for (int i = 0; i < row; i++)
if (chessboard[i][col] == 'Q') return false;
// 检查左上45°
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--)
if (chessboard[i][j] == 'Q') return false;
// 检查右上45°
for (int i = row - 1, j = col + 1; i >= 0 && j < depth; i--, j++)
if (chessboard[i][j] == 'Q') return false;
return true;
}
};
class Solution {
public:
void solveSudoku(vector<vector<char>>& board) {
backtracking(board);
}
bool backtracking(vector<vector<char>>& board) {
// 二维递归，遍历每一个位置
for (int i = 0; i < board.size(); i++) {
for (int j = 0; j < board[0].size(); j++) {
// 当前位置有数字，跳过
if (board[i][j] != '.')
continue;
// 空则尝试填入数字
for (char c = '1'; c <= '9'; c++) {
// 合法
if (check(i, j, c, board)) {
board[i][j] = c; // 填入c
// 如果找到合适一组立刻返回
if (backtracking(board)) return true;
board[i][j] = '.'; // 回溯
}
}
// 9个数都试完了，都不行，那么就返回false
// 【注意】没有终止条件也不会因为永远填不满棋盘而无限递归下去
return false;
}
}
// 遍历完所有位置不报错，说明找到了唯一解
return true;
}
bool check(int row, int col, char c, vector<vector<char>>& board) {
// 每一行只能出现一次，如果已经有该数字则不合法
for (int j = 0; j < 9; j++) {
if (board[row][j] == c)
return false;
}
// 每一列只能出现一次，如果已经有该数字则不合法
for (int i = 0; i < 9; i++) {
if (board[i][col] == c)
return false;
}
// 小方格是否重复
// 遇见0,1,2 相当于从下标0开始
// 遇见3,4,5 相当于从下标3开始
// 遇见6,7,8 相当于从下标6开始
int startRow = row / 3 * 3;
int startCol = col / 3 * 3;
for (int i = startRow; i < startRow + 3; i++) {
for (int j = startCol; j < startCol + 3; j++) {
if (board[i][j] == c)
return false;
}
}
return true;
}
};
性能分析
子集问题分析：
- 时间复杂度： O ( n × 2 n ) O(n × 2^n) O(n×2n)，因为每一个元素的状态无外乎取与不取，所以时间复杂度为 O ( 2 n ) O(2^n) O(2n)，构造每一组子集都需要填进数组，又有需要 O ( n ) O(n) O(n)，最终时间复杂度： O ( n × 2 n ) O(n × 2^n) O(n×2n)。
- 空间复杂度： O ( n ) O(n) O(n)，递归深度为n，所以系统栈所用空间为 O ( n ) O(n) O(n)，每一层递归所用的空间都是常数级别，注意代码里的result和path都是全局变量，就算是放在参数里，传的也是引用，并不会新申请内存空间，最终空间复杂度为 O ( n ) O(n) O(n)。
排列问题分析：
- 时间复杂度：
O
(
n
!
)
O(n!)
O(n!)，这个可以从排列的树形图中很明显发现，每一层节点为n，第二层每一个分支都延伸了n-1个分支，再往下又是n-2个分支，所以一直到叶子节点一共就是 n * n-1 * n-2 * … 1 = n!。每个叶子节点都会有一个构造全排列填进数组的操作（对应的代码：
result.push_back(path)），该操作的复杂度为 O ( n ) O(n) O(n)。所以，最终时间复杂度为：n * n!，简化为 O ( n ! ) O(n!) O(n!)。 - 空间复杂度： O ( n ) O(n) O(n)，和子集问题同理。
组合问题分析：
- 时间复杂度： O ( n × 2 n ) O(n × 2^n) O(n×2n)，组合问题其实就是一种子集的问题，所以组合问题最坏的情况，也不会超过子集问题的时间复杂度。
- 空间复杂度： O ( n ) O(n) O(n)，和子集问题同理。
一般说道回溯算法的复杂度，都说是指数级别的时间复杂度，这也算是一个概括吧！
N皇后问题分析：
- 时间复杂度：O(n!) ，其实如果看树形图的话，直觉上是O(n^n)，但皇后之间不能见面所以在搜索的过程中是有剪枝的，最差也就是O（n!），n!表示n * (n-1) * … * 1。
- 空间复杂度：O(n)，和子集问题同理。
解数独问题分析：
- 时间复杂度：O(9^m) , m是’.'的数目。
- 空间复杂度：O(n^2)，递归的深度是n的二次方
377
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
