对组合、分割、子集、排列、棋盘问题和其他的针对性学习，知识浓度upupup~
讲解
参考代码随想录，其他里面有自己找来的例题
回溯是一种搜索方式，回溯的本质是穷举，穷举所有可能，然后选出一个想要的答案，如果想要回溯法更高效一点，可以加一些剪枝操作，但也改不了回溯法就是穷举的本质。
所以回溯法并不高效，使用他是因为没得选，有些问题能暴力出来就不错了，撑死再剪枝一下。
回溯一般能解决的问题如下：
- 组合问题：N个数里面按一定规则找出k个数的集合
- 切割问题：一个字符串按一定规则有几种切割方式
- 子集问题：一个N个数的集合里有多少符合条件的子集
- 排列问题：N个数按一定规则全排列，有几种排列方式
- 棋盘问题：N皇后，解数独等等
所有的回溯法都可以抽象成树形结构，因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度就构成了树的深度。
回溯伪代码：
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
组合
组合
给定两个整数 n 和 k ，返回 1…n 中所有可能的 k 个数的组合。
经典回溯法，暴力的解法就是嵌套for循环，k为2就嵌套2个for循环，每个for循环都解决一个数，k为3就3个for循环。k如果非常大，这代码就写不出来了，所以可以使用回溯法，回溯法虽然也是暴力，但至少能写。
回溯法是使用递归来解决嵌套层数的问题。
树形结构：
可以看出这棵树，一开始集合是1，2，3，4，从左向右取数，取过的数，不再重复取，每次从集合中选取元素，可选择的范围随着选择的进行而收缩，调整可选择的范围。n相当于树的宽度，k相当于树的深度。在树上遍历，每次遍历到叶子节点，就找到了一个结果。
- 递归函数的返回值以及参数：这里定义两个全局变量，一个用来存放符合条件单一结果，一个用来存放符合条件结果的集合。
vector<int> path和vector<vector<int>> res，还需要一个startIndex来记录本层递归中，集合从哪里开始遍历的，为的就是防止出现重复的组合。 - 回溯的终止条件：到达叶子节点的时候可以终止，path这个数组的大小如果达到k，说明我们找到了一个子集大小为k的组合了，path存的就是根节点到叶子节点的路径。此时用res将path存起来。
- 单层搜索的过程：回溯法的搜索过程就是一个树形结构的遍历过程，for循环用来横向遍历，递归的过程是纵向遍历。
什么时候需要startIndex?
如果是一个集合来求组合的话，就需要startIndex，例如：组合 ，组合总和III。
如果是多个集合取组合，各个集合之间相互不影响，那么就不用startIndex，例如：电话号码的字母组合
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) {
backtracking(n, k, 1);
return result;
}
};
剪枝优化
要求的是组合数，所以12和21是一样的，这样依赖就会多很多无用的遍历操作
如何优化呢？
- 已经选择的元素个数：path.size()
- 所需需要的元素个数为k - path.size()
- 列表中剩余元素(n - i) >= 所需需要的元素个数k - path.size()
- 在集合n中至多要从该起始位置 : i <= n - (k - path.size()) + 1，开始遍历
优化之后的代码为：
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;
}
};
组合总和III
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
说明：
所有数字都是正整数。
解集不能包含重复的组合。
- 需要path和res为全局变量。还需要参数targetSum目标和，也就是题目中的n；k就是题目中要求k个数的集合；sum是已经收集的元素总和，也就是path里元素的总和；startIndex为下一层for循环搜索的起始位置。
vector<vector<int>> result;
vector<int> path;
void backtracking(int targetSum, int k, int sum, int startIndex)
- k其实就已经限制树的深度，因为就取k个元素，树再往下深了没有意义。如果path.size() == k相等，就终止了。
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(); // 回溯
}
完整代码：
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;
}
};
剪枝：
已选元素总和如果已经大于n，那么往后遍历就没有意义了，直接剪掉
if(sum > targetSum)
return;
for的循环范围也可以剪
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(); // 回溯
}
完整代码：
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;
}
};
电话号码的字母组合
给定一个仅包含数字2~9的字符串，返回所有它能表示的字母组合。给出数字到字母映射如下，1不对应任何字母。
数字和字母如何映射？
使用map或者定义一个二维数组，例如：string letterMap[10]
const string letterMap[10] = {
"",//0
"",//1
"abc",//2
"def",//3
"ghi",//4
"jkl",//5
"mno",//6
"pqrs",//7
"tuv",//8
"wxyz",//9
};
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(); // 回溯
}
完整代码：
class Solution {
private:
const string letterMap[10] = {
"",
"",
"abc",
"def",
"ghi",
"jkl",
"mno",
"pqrs",
"tuv",
"wxyz",
};
void backtracking(string digits, int index){
if(path.size() == digits.size()){
res.push_back(path);
return;
}
int digit = digits[index] - '0';
string letter = letterMap[digit];
for(int i = 0; i < letter.size(); i ++){
path.push_back(letter[i]);
backtracking(digits, index + 1);
path.pop_back();
}
}
public:
vector<string> res;
string path;
vector<string> letterCombinations(string digits) {
if(digits.size() == 0) return res;//这里必须return res,不然空集就会return [""],但实际上我们需要[]
backtracking(digits, 0);
return res;
}
};
组合总和
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
终止只有两种情况，sum大于target和sum等于target。
if (sum > target) {
return;
}
if (sum == target) {
result.push_back(path);
return;
}
单层搜索逻辑：for依然是从startIndex开始，搜索candidates集合
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(); // 回溯
}
完整代码：
class Solution {
private:
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;
}
};
在上面的代码中，对于sum已经大于target的情况，其实是依然进入下一层递归，只是下一层递归结束判断的时候，会判断sum>target的话就返回。其实如果知道一下层的sum大于target，就没有必要进入下一层递归了，针对这个，可以在for循环上做文章。
剪枝代码for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++)
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& candidates, int target, int sum, int startIndex) {
if (sum == target) {
result.push_back(path);
return;
}
// 如果 sum + candidates[i] > target 就终止遍历
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
sum += candidates[i];
path.push_back(candidates[i]);
backtracking(candidates, target, sum, i);
sum -= candidates[i];
path.pop_back();
}
}
public:
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
result.clear();
path.clear();
sort(candidates.begin(), candidates.end()); // 需要排序
backtracking(candidates, target, 0, 0);
return result;
}
};
组合总和II
给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
与组合总和的区别在于，II的candidates中每个数字在每个组合中只能使用一次，并且II的candidates中的元素宿舍可以有重复的，而组合总和是无重复的
所以，本题难点在于，数组candidates有重复元素，但还不能有重复的组合
所以需要去重，去重就是使用过的元素不能重复选取
- 树层去重还是数枝去重？
首先将candidates排序，接下来树层去重
如何避免第二次取到1呢，可以设置一个used数组，来标记是否访问过。如果candidates[i] == candidates[i - 1]并且used[i - 1] == false，就说明：前一个树枝，使用了candidates[i - 1]，也就是说同一树层使用过candidates[i - 1]。
为什么used[i - 1] == false 代表树层重复呢？因为同一树层，used[i - 1] == false 才能表示，当前取的 candidates[i] 是从 candidates[i - 1] 回溯而来的。
- used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
- used[i - 1] == false，说明同一树层candidates[i - 1]使用过
- 所以单层逻辑：
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {
// used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
// used[i - 1] == false，说明同一树层candidates[i - 1]使用过
// 要对同一树层使用过的元素进行跳过
if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
continue;
}
sum += candidates[i];
path.push_back(candidates[i]);
used[i] = true;
backtracking(candidates, target, sum, i + 1, used); // 和组合总和的区别：这里是i+1，每个数字在每个组合中只能使用一次
used[i] = false;
sum -= candidates[i];
path.pop_back();
}
整体代码：
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& candidates, int target, int sum, int startIndex, vector<bool>& used) {
if (sum == target) {
result.push_back(path);
return;
}
for (int i = startIndex; i < candidates.size() && sum + candidates[i] <= target; i++) {// 加上sum + candidates[i] <= target效率高很多
// used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
// used[i - 1] == false，说明同一树层candidates[i - 1]使用过
// 要对同一树层使用过的元素进行跳过
if (i > 0 && candidates[i] == candidates[i - 1] && used[i - 1] == false) {
continue;
}
sum += candidates[i];
path.push_back(candidates[i]);
used[i] = true;
backtracking(candidates, target, sum, i + 1, used); // 和39.组合总和的区别1，这里是i+1，每个数字在每个组合中只能使用一次
used[i] = false;
sum -= candidates[i];
path.pop_back();
}
}
public:
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
vector<bool> used(candidates.size(), false);
path.clear();
result.clear();
// 首先把给candidates排序，让其相同的元素都挨在一起。
sort(candidates.begin(), candidates.end());
backtracking(candidates, target, 0, 0, used);
return result;
}
};
分割
分割回文串
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串。返回 s 所有可能的分割方案。
组合问题和切割问题的区别：
- 组合问题：选取一个a之后，在bcdef中再去选取第二个，选取b之后在cdef中再去选取第三个…
- 切割问题：切割一个a之后，在bcdef中再去切割第二段，切割b之后在cdef中再切割第三段…
所以切割问题，同样可以抽象为一棵树形结构：
所以，切割问题的回溯搜索过程和组合问题的回溯搜索过程差不多的。
- 全局变量存放path和res，还有startIndex
vector<vector<string>> result;
vector<string> path; // 放已经回文的子串
void backtracking (const string& s, int startIndex) {
从树形结构的图中可以看出：切割线切到了字符串最后面，说明找到了一种切割方法，此时就是本层递归的终止条件。
2. 那什么是切割线呢？
在处理组合问题的时候，递归参数需要传入startIndex，表示下一轮递归遍历的起始位置，这个startIndex就是切割线。
所以终止条件代码：
void backtracking (const string& s, int startIndex) {
// 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
if (startIndex >= s.size()) {
result.push_back(path);
return;
}
}
- 单层搜索逻辑：在
for(int i = startIndex; i < s.size(); i ++)的循环中，定义了起始位置startIndex和终止位置i，那么[startIndex, i]就是要截取的子串。
首先判断这个子串是不是回文的，如果是回文的，就加入path中，在递归下一个。
for (int i = startIndex; i < s.size(); i++) {
if (isPalindrome(s, startIndex, i)) { // 是回文子串
// 获取[startIndex,i]在s中的子串
string str = s.substr(startIndex, i - startIndex + 1);
path.push_back(str);
} else { // 如果不是则直接跳过
continue;
}
backtracking(s, i + 1); // 寻找i+1为起始位置的子串
path.pop_back(); // 回溯过程，弹出本次已经添加的子串
}
- 判断是不是回文子串：
- 用双指针法，一个指针从前向后，一个指针从后向前。
- 如果前后指针所指向的元素一直是相等的，就是回文字符串。
bool isPalindrome(const string& s, int start, int end) {
for (int i = start, j = end; i < j; i++, j--) {
if (s[i] != s[j]) {
return false;
}
}
return true;
}
完整代码：
class Solution {
private:
vector<vector<string>> result;
vector<string> path; // 放已经回文的子串
void backtracking (const string& s, int startIndex) {
// 如果起始位置已经大于s的大小，说明已经找到了一组分割方案了
if (startIndex >= s.size()) {
result.push_back(path);
return;
}
for (int i = startIndex; i < s.size(); i++) {
if (isPalindrome(s, startIndex, i)) { // 是回文子串
// 获取[startIndex,i]在s中的子串
string str = s.substr(startIndex, i - startIndex + 1);
path.push_back(str);
} else { // 不是回文，跳过
continue;
}
backtracking(s, i + 1); // 寻找i+1为起始位置的子串
path.pop_back(); // 回溯过程，弹出本次已经添加的子串
}
}
bool isPalindrome(const string& s, int start, int end) {
for (int i = start, j = end; i < j; i++, j--) {
if (s[i] != s[j]) {
return false;
}
}
return true;
}
public:
vector<vector<string>> partition(string s) {
result.clear();
path.clear();
backtracking(s, 0);
return result;
}
};
复原IP地址
给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
有效的 IP 地址 正好由四个整数（每个整数位于 0 到 255 之间组成，且不能含有前导 0），整数之间用 ‘.’ 分隔。
是切割问题，也可以抽象为树形结构：
- 递归参数：startIndex一定是需要的，因为不能重复分割，记录下一层递归分割的起始位置。还需要一个pointNum，记录添加逗点的数量：
vector<string> result;// 记录结果
// startIndex: 搜索的起始位置，pointNum:添加逗点的数量
void backtracking(string& s, int startIndex, int pointNum) {
- 递归终止条件：本文明确要求只会分成4段，所以不能用切割线到最后为终止条件，而是切割的段数，pointNum表示逗点数量，pointNum为3说明字符串分成四段了，然后验证一下第四段是否合法，如果合法就加入到结果集里面。
if (pointNum == 3) { // 逗点数量为3时，分隔结束
// 判断第四段子字符串是否合法，如果合法就放进result中
if (isValid(s, startIndex, s.size() - 1)) {
result.push_back(s);
}
return;
}
- 单层搜索逻辑：和在分割回文串中的截取子串的方式差不多，截取一个子串来判断是否合法，合法就进入下一层递归
for (int i = startIndex; i < s.size(); i++) {
if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
s.insert(s.begin() + i + 1 , '.'); // 在i的后面插入一个逗点
pointNum++;
backtracking(s, i + 2, pointNum); // 插入逗点之后下一个子串的起始位置为i+2
pointNum--; // 回溯
s.erase(s.begin() + i + 1); // 回溯删掉逗点
} else break; // 不合法，直接结束本层循环
}
- 判断子串是否合法：
主要有三点：
- 段位以0开头的数字不合法
- 段位里有非正整数字符不合法
- 段位如果大于255了不合法
// 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
bool isValid(const string& s, int start, int end) {
if (start > end) {
return false;
}
if (s[start] == '0' && start != end) { // 0开头的数字不合法
return false;
}
int num = 0;
for (int i = start; i <= end; i++) {
if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
return false;
}
num = num * 10 + (s[i] - '0');
if (num > 255) { // 如果大于255了不合法
return false;
}
}
return true;
}
完整代码：
class Solution {
private:
vector<string> result;// 记录结果
// startIndex: 搜索的起始位置，pointNum:添加逗点的数量
void backtracking(string& s, int startIndex, int pointNum) {
if (pointNum == 3) { // 逗点数量为3时，分隔结束
// 判断第四段子字符串是否合法，如果合法就放进result中
if (isValid(s, startIndex, s.size() - 1)) {
result.push_back(s);
}
return;// return的位置不能放在if里面
}
for (int i = startIndex; i < s.size(); i++) {
if (isValid(s, startIndex, i)) { // 判断 [startIndex,i] 这个区间的子串是否合法
s.insert(s.begin() + i + 1 , '.'); // 在i的后面插入一个逗点
pointNum++;
backtracking(s, i + 2, pointNum); // 插入逗点之后下一个子串的起始位置为i+2
pointNum--; // 回溯
s.erase(s.begin() + i + 1); // 回溯删掉逗点
} else break; // 不合法，直接结束本层循环
}
}
// 判断字符串s在左闭又闭区间[start, end]所组成的数字是否合法
bool isValid(const string& s, int start, int end) {
if (start > end) {
return false;
}
if (s[start] == '0' && start != end) { // 0开头的数字不合法
return false;
}
int num = 0;
for (int i = start; i <= end; i++) {
if (s[i] > '9' || s[i] < '0') { // 遇到非数字字符不合法
return false;
}
num = num * 10 + (s[i] - '0');
if (num > 255) { // 如果大于255了不合法
return false;
}
}
return true;
}
public:
vector<string> restoreIpAddresses(string s) {
result.clear();
if (s.size() < 4 || s.size() > 12) return result; // 算是剪枝了
backtracking(s, 0, 0);
return result;
}
};
子集
子集
给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。
如果把子集问题、组合问题、分割问题都抽象成一棵树的话，那么组合问题和分割问题都是收集树的叶子节点，而子集问题是找树的所有节点！其实自己也是一种组合问题，只不过他的集合是无序的，子集{1,2}和{2,1}是一样的。
同样取过的元素不会重复，写回溯算法的时候，for从startIndex开始，如果是排列问题的话，就从0开始，因为排列是有序的，{1,2}和{2,1}是两个集合。
假如：nums = [1,2,3]抽象为树型结构：
红线部分可以看出来，遍历这个树需要将所有节点都记录下来，就是要求的子集集合。
- 递归函数参数：path和res，还有startIndex
vector<int> path;
vector<vector<int>> res;
void backtracking(vector<int>& nums, int startIndex){
- 递归终止条件：图中可以看出，剩余集合为空的时候，就是叶子节点。那么什么时候剩余集合为空呢？就是startIndex大于等于数组长度的时候，这样就没有元素可以取了。
if(startIndex >= num.size()){
return;
}
- 单层搜索逻辑：求取子集问题，不需要任何剪枝，因为子集就是要遍历整棵树
for (int i = startIndex; i < nums.size(); i++) {
path.push_back(nums[i]); // 子集收集元素
backtracking(nums, i + 1); // 注意从i+1开始，元素不重复取
path.pop_back(); // 回溯
}
完整代码：
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex) {
result.push_back(path); // 收集子集，要放在终止添加的上面，否则会漏掉自己
if (startIndex >= nums.size()) { // 终止条件可以不加
return;
}
for (int i = startIndex; i < nums.size(); i++) {
path.push_back(nums[i]);
backtracking(nums, i + 1);
path.pop_back();
}
}
public:
vector<vector<int>> subsets(vector<int>& nums) {
result.clear();
path.clear();
backtracking(nums, 0);
return result;
}
};
子集II
给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
说明：解集不能包含重复的子集。
和子集的区别就是集合里面有重复元素了，所以求取的子集需要去重，回溯算法的在组合总和II中给过详细讲解，和本题一样。
同一树层上重复取 2 就要过滤掉，同一树枝上就可以重复取2，因为同一树枝上元素的集合才是唯一子集。
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex, vector<bool>& used) {
result.push_back(path);
for (int i = startIndex; i < nums.size(); i++) {
// used[i - 1] == true，说明同一树枝candidates[i - 1]使用过
// used[i - 1] == false，说明同一树层candidates[i - 1]使用过
// 而我们要对同一树层使用过的元素进行跳过
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();
}
}
public:
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
result.clear();
path.clear();
vector<bool> used(nums.size(), false);
sort(nums.begin(), nums.end()); // 去重需要排序
backtracking(nums, 0, used);
return result;
}
};
排列
全排列
给定一个 没有重复 数字的序列，返回其所有可能的全排列。
输入: [1,2,3]
输出: [ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]
以[1,2,3]为例，抽象成树形结构：
- 递归函数参数：排序说明要讲究顺序，[1,2]和[2,1]是两个集合，这和之前分析的子集以及组合所不同的地方。可以看出元素1在[1,2]中已经使用过了，又在[2,1]中使用，所以处理排列问题就不用使用startIndex，但排列问题需要一个used数组，标记已经选择的元素，如图黄色部分
vector<int> path;
vector<vector<int>> res;
void backtracking(vector<int>& nums, vector<bool>& used)
- 递归终止条件：叶子节点，就是收割结果的地方，path的大小和nums数组一样大的时候，说明找到了一个全排列，也表示到了叶子节点。
if(path.size() == nums.size()){
res.push_back(path);
return;
}
- 单层搜索的逻辑：最大的不同就是for循环里不用startIndex了，因为排列每次都要从头开始搜索。而used数组，其实就是记录此时path里有哪些元素使用了，一个排列里一个元素只能使用一次。
for (int i = 0; i < nums.size(); i++) {
if (used[i] == true) continue; // path里已经收录的元素，直接跳过
used[i] = true;
path.push_back(nums[i]);
backtracking(nums, used);
path.pop_back();
used[i] = false;
}
整体代码：
class Solution {
public:
vector<vector<int>> result;
vector<int> path;
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++) {
if (used[i] == true) continue; // path里已经收录的元素，直接跳过
used[i] = true;
path.push_back(nums[i]);
backtracking(nums, used);
path.pop_back();
used[i] = false;
}
}
vector<vector<int>> permute(vector<int>& nums) {
result.clear();
path.clear();
vector<bool> used(nums.size(), false);
backtracking(nums, used);
return result;
}
};
全排列II
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。
与全排列的区别在于给定的是一个包含重复数字的序列，要返回所有不重复的全排列
所以就涉及到去重了！
还要强调的是去重一定要对元素进行排序，这样我们才方便通过相邻的节点来判断是否重复使用了。
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
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++) {
// used[i - 1] == true，说明同一树枝nums[i - 1]使用过
// used[i - 1] == false，说明同一树层nums[i - 1]使用过
// 如果同一树层nums[i - 1]使用过则直接跳过
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
continue;
}
if (used[i] == false) {
used[i] = true;
path.push_back(nums[i]);
backtracking(nums, used);
path.pop_back();
used[i] = false;
}
}
}
public:
vector<vector<int>> permuteUnique(vector<int>& nums) {
result.clear();
path.clear();
sort(nums.begin(), nums.end()); // 排序
vector<bool> used(nums.size(), false);
backtracking(nums, used);
return result;
}
};
棋盘问题
N皇后
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
首先来看一下皇后们的约束条件：
- 不能同行
- 不能同列
- 不能同斜线
- 递归函数参数：res全局变量，参数n是棋盘大小，row来遍历到棋盘的第几层了
vector<vector<string>> res;
void backtracking(int n, int row, vector<string>& chessboard){
- 单层搜索逻辑：递归深度就是row控制棋盘的行，每一层里for循环的col控制棋盘的列，一行一列，确定了放的位置。每次都是要从新的一行的起始位置开始搜，所以都是从0开始的。
for(int col = 0; col < n; col ++){
if(isValid(row, col, chessboard, n)){ // 验证合法就可以放
chessboard[row][col] = 'Q'; // 放置皇后
backtracking(n, row + 1, chessboard);
chessboard[row][col] = '.'; // 回溯
}
- 验证棋盘是否合法
有三个标准：不能同行，不能同列，不能同斜线
bool isValid(int row, int col, vector<string>& chessboard, int n) {
// 检查列
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;
}
}
// 检查 135度角是否有皇后
for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
if (chessboard[i][j] == 'Q') {
return false;
}
}
return true;
}
完整代码
class Solution {
private:
// n 为输入的棋盘大小
// row 是当前递归到棋盘的第几行了
void backtracking(int n, int row, vector<string>& chessboard) {
if (row == n) {
result.push_back(chessboard);
return;
}
for (int col = 0; col < n; col++) {
if (isValid(row, col, chessboard, n)) { // 验证合法就可以放
chessboard[row][col] = 'Q'; // 放置皇后
backtracking(n, row + 1, chessboard);
chessboard[row][col] = '.'; // 回溯，撤销皇后
}
}
}
bool isValid(int row, int col, vector<string>& chessboard, int n) {
// 检查列
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;
}
}
// 检查 135度角是否有皇后
for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
if (chessboard[i][j] == 'Q') {
return false;
}
}
return true;
}
public:
vector<vector<string>> res; // 全局变量,必须放这里
vector<vector<string>> solveNQueens(int n) {
vector<string> chessboard(n, string(n, '.'));
backtracking(n, 0, chessboard);
return result;
}
};
解数独
编写一个程序，通过填充空格来解决数独问题。
一个数独的解法需遵循如下规则：
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。
空白格用 ‘.’ 表示。
棋盘搜索问题可以使用回溯法暴力搜索，只不过这次我们要做的是二维递归。
N皇后是因为每一行每一列只放一个皇后，只需要一层for循环遍历一行，递归来遍历列，然后一行一列确定皇后的唯一位置。本题不一样，本题中棋盘的每一个位置都要放一个数字（而N皇后是一行只放一个皇后），并检查数字是否合法，解数独的树形结构要比N皇后更宽更深。
- 递归函数的返回值是bool类型的，因为解数独找到一个符合的条件立刻就返回，相当于找从根节点到叶子结点一条唯一路径，所以需要使用bool返回值
bool backtracking(vector<vector<char>>& board)
- 递归终止条件：没有终止条件，数字填完会自然终止。因为如果一行一列确定下来了，这里尝试了9个数都不行，说明这个棋盘找不到解决数独问题的解！
- 单层递归逻辑：一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，一行一列确定下来之后，递归遍历这个位置放9个数字的可能性！
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 k = '1'; k <= '9'; k++) { // (i, j) 这个位置放k是否合适
if (isValid(i, j, k, board)) {
board[i][j] = k; // 放置k
if (backtracking(board)) return true; // 如果找到合适一组立刻返回
board[i][j] = '.'; // 回溯，撤销k
}
}
return false; // 9个数都试完了，都不行，那么就返回false
}
}
return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}
- 判断棋盘是否合法：同行是否重复，同列是否重复，9宫格是否重复
bool isValid(int row, int col, char val, vector<vector<char>>& board) {
for (int i = 0; i < 9; i++) { // 判断行里是否重复
if (board[row][i] == val) {
return false;
}
}
for (int j = 0; j < 9; j++) { // 判断列里是否重复
if (board[j][col] == val) {
return false;
}
}
int startRow = (row / 3) * 3;
int startCol = (col / 3) * 3;
for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
for (int j = startCol; j < startCol + 3; j++) {
if (board[i][j] == val ) {
return false;
}
}
}
return true;
}
整体代码：
class Solution {
private:
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] == '.') {
for (char k = '1'; k <= '9'; k++) { // (i, j) 这个位置放k是否合适
if (isValid(i, j, k, board)) {
board[i][j] = k; // 放置k
if (backtracking(board)) return true; // 如果找到合适一组立刻返回
board[i][j] = '.'; // 回溯，撤销k
}
}
return false; // 9个数都试完了，都不行，那么就返回false
}
}
}
return true; // 遍历完没有返回false，说明找到了合适棋盘位置了
}
bool isValid(int row, int col, char val, vector<vector<char>>& board) {
for (int i = 0; i < 9; i++) { // 判断行里是否重复
if (board[row][i] == val) {
return false;
}
}
for (int j = 0; j < 9; j++) { // 判断列里是否重复
if (board[j][col] == val) {
return false;
}
}
int startRow = (row / 3) * 3;
int startCol = (col / 3) * 3;
for (int i = startRow; i < startRow + 3; i++) { // 判断9方格里是否重复
for (int j = startCol; j < startCol + 3; j++) {
if (board[i][j] == val ) {
return false;
}
}
}
return true;
}
public:
void solveSudoku(vector<vector<char>>& board) {
backtracking(board);
}
};
其他
递增子序列
给定一个整型数组, 你的任务是找到所有该数组的递增子序列，递增子序列的长度至少是2。
这个递增子序列有点像取有序的子集，而且本题也要求不能有相同的递增子序列。所以很像子集II，但是差别也有。
子集II中是通过排序，再加上标记一个数组来达到去重的目的，而本题求自增子序列，是不能对原数组进行排序的，排完序的数组就都成自增子序列了。
所以不能使用子集II的去重逻辑！
将数组{4,7,6,7}抽象为树型结构：
- 递归函数参数：本题求子序列，明显一个元素不能重复使用，所以需要startIndex，调整下一层递归的起始位置
vector<int> path;
vector<vector<int>> res;
void backtracking(vector<int>& nums, int startIndex)
- 终止条件
本题其实类似求子集问题，也是要遍历树形结构找每一个节点，本题收集结果有所不同，题目要求递增子序列大小至少为2，所以代码如下：
if(path.size() > 1) res,push_back(path);
- 单层搜索逻辑：如图，同一父节点下的同层上使用过的元素就不能再使用了，那么代码如下
unordered_set<int> uset; // 使用set来对本层元素进行去重
for(int i = startIndex; i < nums.size(); i ++){
if((!path.empty() && nums[i] < path.back()) || uset.fin(nums[i]) != uset.end()) continue;
uset.insert(nums[i]);// 记录这个元素在本层使用过了
path.push_back(nums[i]);
backtracking(nums, i + 1);
path.pop_back();
}
为什么没有uset的pop操作呢？因为没有把他放在全局变量的位置，从代码上看uset是在每一次递归调用（或者说是在每个递归层次）之前就已经被定义好了，这意味着它的生命周期仅仅存在于单次的递归调用中。
class Solution {
private:
vector<vector<int>> result;
vector<int> path;
void backtracking(vector<int>& nums, int startIndex) {
if (path.size() > 1) {
result.push_back(path);
// 注意这里不要加return，要取树上的节点
}
unordered_set<int> uset; // 使用set对本层元素进行去重
for (int i = startIndex; i < nums.size(); i++) {
if ((!path.empty() && nums[i] < path.back())
|| uset.find(nums[i]) != uset.end()) {
continue;
}
uset.insert(nums[i]); // 记录这个元素在本层用过了，本层后面不能再用了
path.push_back(nums[i]);
backtracking(nums, i + 1);
path.pop_back();
}
}
public:
vector<vector<int>> findSubsequences(vector<int>& nums) {
result.clear();
path.clear();
backtracking(nums, 0);
return result;
}
};
扫一扫
839
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
