回溯算法
- 什么是回溯算法？
- 回溯算法也可以叫做回溯搜索法，它是一种搜索方式。
- 回溯是递归的副产品，只要有递归就会有回溯。
- 回溯法的效率:
- 回溯法的本质是穷举，穷举所有可能，然后选出我们想要的答案。(n层for循环嵌套)
- 如果想让回溯法更高效一些，可以加一些剪枝操作，但也无法改变回溯法就是穷举的本质。
- 回溯法一般可以解决如下几种问题:
- 组合问题: N个数里面按一定规则找出K个数的集合
- 切割问题: 一个字符串按一定规则由于几种切割方式
- 子集问题: 一个N个数的集合里有多少符合条件的子集
- 排列问题: N个数按一定规则全排列，有几种排列方式。
- 棋盘问题: N皇后，解数独等
- 如何理解回溯法?
- 回溯法解决的都可以抽象为树型结构。
- 因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度构成了树的深度。
- 递归要有终止条件，所以必然是一棵高度有限的树(N叉树)
- 回溯模板
- for循环横向遍历，递归 纵向遍历，回溯不断调整结果集。
void backtracking(参数) {
if (终止条件) {
存放结果;
return;
}
// for循环-横向遍历
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
backtracking(路径，选择列表); // 递归-纵向遍历
回溯，撤销处理结果
}
}
- 性能分析
- 组合问题分析
- 时间复杂度: O ( n ∗ 2 n ) O(n* 2^n) O(n∗2n)
- 组合问题其实就是一种子集问题，所以组合问题最坏的情况，也不会超过子集问题的时间复杂度。
- 空间复杂度: O ( n ) O(n) O(n)
- 子集问题分析
- 时间复杂度: O ( n ∗ 2 n ) O(n * 2^n) O(n∗2n)
- 每种元素状态无非选与不选，所以时间复杂度为&O(2^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) O(n)
- 每一层递归所用的空间都是常数级别，注意代码里的result和path都是全局变量，就算是放在参数里，传引用，并不会重新申请内存。
- 排列问题
- 时间复杂度: 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)
class Solution {
public:
vector<int>path;// 选取的组合
vector<vector<int>>ret;// 最终结果
// 用startIndex来记录下一层递归搜索的起始位置
// 防止重现重复的组合
void backtracking(int n ,int k ,int startIndex){
if(path.size() == k){
ret.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) {
backtracking(n,k,1);
return ret;
}
};
class Solution {
public:
vector<int>path;// 选取的组合
vector<vector<int>>ret;// 最终结果
// 用startIndex来记录下一层递归搜索的起始位置
// 防止重现重复的组合
void backtracking(int n ,int k ,int startIndex){
if(path.siz)e() == k){
ret.push_back(path);// 收集结果
return ;
}
// 如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。
for (int i = startIndex; i <= n - (k - path.size()) + 1; i++){ // i为本次搜索的起始位置
path.push_back(i);// 添加
backtracking(n,k,i+1);// 纵向遍历
path.pop_back();// 撤销
}
}
vector<vector<int>> combine(int n, int k) {
backtracking(n,k,1);
return ret;
}
};
- 模板题，在上一题的基础上，在收集结果的时候增加是否等于目标值的判断。
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
void backtracking(int k, int n,int startIndex){
if(path.size() == k){
// 满足指定和才收集
if(accumulate(path.begin(),path.end(),0) == n)ret.push_back(path);
return ;
}
for(int i = startIndex;i <= 9;i++){
path.push_back(i);
backtracking(k,n,i+1);
path.pop_back();
}
}
vector<vector<int>> combinationSum3(int k, int n) {
backtracking(k,n,1);
return ret;
}
};
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
void backtracking(int k, int n,int startIndex){
if(path.size() == k){
// 满足指定和才收集
if(accumulate(path.begin(),path.end(),0) == n)ret.push_back(path);
return ;
}
for(int i = startIndex;i <= 9-(k-path.size())+1;i++){// 剩余元素个数不足了，终止
path.push_back(i);
if(accumulate(path.begin(),path.end(),0) > n){// 已经大于目标值了，剪掉
path.pop_back();
return;
}
backtracking(k,n,i+1);
path.pop_back();
}
}
vector<vector<int>> combinationSum3(int k, int n) {
backtracking(k,n,1);
return ret;
}
};
- 注意题目的意思是，根据这几个数字所对应的字母进行组合。几个数字，每个组合就有几个元素。
- 从每个数字对应的元素中取一个。然后组合。
- 与上面题的不同，本体每一个数字代表的是不同的组合，也就是求不同集合之间的组合，而上面两道题，都是都同一个集合中的组合。
class Solution {
public:
string path;
vector<string>ret;
const string letterMap[10] = {
"", // 0
"", // 1
"abc", // 2
"def", // 3
"ghi", // 4
"jkl", // 5
"mno", // 6
"pqrs", // 7
"tuv", // 8
"wxyz", // 9
};
void backtracking(const string& digits,int index){
if(index == digits.size()){// 每个数字对应的字母都取了一个，收集。
ret.push_back(path);;
return;
}
int digit = digits[index]-'0';//将对应char转为int
string letters = letterMap[digit];
for(int i = 0; i< letters.size();i++){
path.push_back(letters[i]);
backtracking(digits,index+1);
path.pop_back();
}
}
vector<string> letterCombinations(string digits) {
if(digits.size() == 0)return ret;
backtracking(digits,0);
return ret;
}
};
- 隐藏回溯细节
- 增加参数s,每次修改仅在调用递归函数传参时修改，递归结束返回回来，原值并未被修改。从而达到回溯效果。
class Solution {
public:
const string letterMap[10] = {
"", // 0
"", // 1
"abc", // 2
"def", // 3
"ghi", // 4
"jkl", // 5
"mno", // 6
"pqrs", // 7
"tuv", // 8
"wxyz", // 9
};
vector<string>ret;
void backtracking(const string& digits,string s,int index){// 增加参数string
if(index == digits.size()){
ret.push_back(s);
return ;
}
int digit = digits[index]-'0';
string leeters = letterMap[digit];
for(int i =0; i < leeters.size();i++){
backtracking(digits,s+leeters[i],index+1);// 回溯
}
}
vector<string> letterCombinations(string digits) {
if(digits.size() == 0)return ret;
string s;
s.clear();
backtracking(digits,s,0);
return ret;
}
};
- 注意题目要求，所有元素不限制选取次数。在我们实际的代码中，要修改模板的控制下标。
>- 方法1: 需要排序，因为按顺序取，需要判断是否超出目标值，超过则终止当前层的选取——剪枝。
class Solution {
public:
vector<vector<int>>ret;
vector<int>path;
void backtracking(vector<int>& candidates,int target,int startIndex){
if(accumulate(path.begin(),path.end(),0) == target){
ret.push_back(path);
return ;
}
for(int i = startIndex; i < candidates.size();i++){
path.push_back(candidates[i]);
if(accumulate(path.begin(),path.end(),0) > target){// 在这里终止，因为是排序过了，后面的只会更大。所以终止选取。
path.pop_back();
return;
}
backtracking(candidates,target,i);// 不加1，重复当前值
path.pop_back();
}
// 或者
// for(int i = startIndex; i < candidates.size() && accumulate(path.begin(),path.end(),0) < target;i++){
// path.push_back(candidates[i]);
// backtracking(candidates,target,i);
// path.pop_back();
// }
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
sort(candidates.begin(),candidates.end());// 注意排序
backtracking(candidates,target,0);
return ret;
}
};
- 方法2: 无序排序，递归后，收集结果前判断，是否超过目标，超过目标值终止计算，返回，继续选取下一个值。因为没排序，后面可能还有符合条件的。
注意对比与方法1终止条件位置的不同。
class Solution {
public:
vector<vector<int>>ret;
vector<int>path;
void backtracking(vector<int>& candidates,int target,int startIndex){
if(accumulate(path.begin(),path.end(),0) > target){// 超过目标值则回退，不要再选啦。
return ;
}
if(accumulate(path.begin(),path.end(),0) == target){
ret.push_back(path);
return ;
}
for(int i = startIndex; i < candidates.size();i++){
path.push_back(candidates[i]);
backtracking(candidates,target,i);
path.pop_back();
}
}
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
backtracking(candidates,target,0);
return ret;
}
};
- 错误提示:
- 参数startIndex，传递的时候不同于上面的两题，而是传入当前收集的值的下标，i，不是i+1,为了继续重复选取当前元素。
- 开始我每次传的都是0，这样会造成重复的组合。
- 在上一题的基础上增加去重
- 去重1: 使用startIndex去重
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
void backtracking(vector<int>& candidates,int target,int stratIndex){
if(accumulate(path.begin(),path.end(),0) == target){
ret.push_back(path);
return ;
}
for(int i = stratIndex;i < candidates.size();i++){
// 去重
if(i > stratIndex && candidates[i] == candidates[i-1])continue;
path.push_back(candidates[i]);
if(accumulate(path.begin(),path.end(),0) > target){
path.pop_back();
return;
}
backtracking(candidates,target,i+1);
path.pop_back();
}
}
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
sort(candidates.begin(),candidates.end());
backtracking(candidates,target,0);
return ret;
}
};
- 使用used数组去重——
下面的90题子集II有更详细的去重解释。
- 同一个树枝上的元素可以重复，同一个树层上的元素不可以重复。去的就是同一个树层的重。
- 详见代码中的注释。
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
void backtracking(vector<int>& candidates,int target,int stratIndex,vector<bool>&used){
if(accumulate(path.begin(),path.end(),0) == target){
ret.push_back(path);
return ;
}
for(int i = stratIndex;i < candidates.size();i++){
// 去重，跳过同一层使用过的元素
// used[i-1] == true,表明同一个树枝candiates[i-1]使用过——联想往下纵向遍历。
// used[i-1] == false,表明同一个树层candiates[i-1]使用过——联想往右横向遍历。
// 为什么？ used[i-1] == false;
// 因为，同一树层，used[i-1] == false才能表示，当前取的candidates[i]是从candidates[i-1]回溯而来。
// used[i-1] == true 说明进入下一层递归，向下纵向遍历，同一个树枝上使用过啦。
// 与前一个元素与当前元素相等，并且在同一个树枝使用过，去掉。
if(i > 0 && candidates[i] == candidates[i-1] &&
used[i-1] == false)continue;
path.push_back(candidates[i]);
if(accumulate(path.begin(),path.end(),0) > target){
path.pop_back();
return;
}
used[i] = true;// 树枝使用了，遍历
backtracking(candidates,target,i+1,used);
used[i] = false;
path.pop_back();
}
}
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
sort(candidates.begin(),candidates.end());
vector<bool>used(candidates.size(),false);
backtracking(candidates,target,0,used);
return ret;
}
};
- 可以说是回溯模板题，只是收集结果方式有所不同，判断从某一位置截取到当前位置的字串是否为回文字串， 是则收集。
class Solution {
public:
// 判断是否为回文子串-双指针
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;
}
vector<vector<string>>ret;
vector<string>path;
void backtracking(const string& s, int startIndex){
if(startIndex >= s.size()){// 收集一轮结果
ret.push_back(path);
return ;
}
for(int i = startIndex;i < s.size();i++){
// 想象了一下搜索过程，每次递归刚进入先选一个字母，直到最后，然后开始返回，倒数第二次选两个，依次回溯调整选取状态...其中要判断每次选取的子串是否为回文子串。
if(isPalindrome(s,startIndex,i)){// 是回文字串
string str = s.substr(startIndex,i-startIndex+1);
path.push_back(str);// 收集
}else continue;//不是回文字串
backtracking(s,i+1);// 切割的地方不能重复切割，所以传入i+1
path.pop_back();// 回溯
}
}
vector<vector<string>> partition(string s) {
backtracking(s,0);
return ret;
}
};
- 优化，提前计算出某一个子串是否是回文字串。dp思想。
- 具体来说, 给定一个字符串s, 长度为n, 它成为回文字串的充分必要条件是s[0] == s[n-1]且s[1:n-1]是回文字串。
class Solution {
public:
vector<vector<string>>ret;
vector<string>path;
vector<vector<bool>>isPalindrome;
void backtracking(const string& s, int startIndex){
if(startIndex >= s.size()){// 收集一轮结果
ret.push_back(path);
return ;
}
for(int i = startIndex;i < s.size();i++){
if(isPalindrome[startIndex][i]){// 是回文字串
string str = s.substr(startIndex,i-startIndex+1);
path.push_back(str);// 收集
}else continue;//不是回文字串
backtracking(s,i+1);
path.pop_back();// 回溯
}
}
// 计算每个子串是否为回文字串
void computePalindrome(const string& s){
isPalindrome.resize(s.size(),vector<bool>(s.size(),false));
for(int i = s.size()-1;i >= 0;i--){
for(int j = i;j < s.size();j++){
if(j ==i)isPalindrome[i][j] = true;
else if(j - i == 1)isPalindrome[i][j] = (s[i] == s[j]);
else isPalindrome[i][j] = (s[i]==s[j] && isPalindrome[i+1][j-1]);
}
}
}
vector<vector<string>> partition(string s) {
computePalindrome(s);
backtracking(s,0);
return ret;
}
};
- 同上切割问题，可以使用回溯搜索法把所有可能性搜出来。
class Solution {
public:
vector<string>ret;
bool isValid(const string& s,int start,int end){
if(start > end)return false;
if(s[start] == '0' && start != end)return false;// 前导0，不合法
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)return false;
}
return true;
}
void backtracking(string& s,int startIndex,int pointCount){
if(pointCount == 3){
if(isValid(s,startIndex,s.size()-1)){// 判断最后一段是不是合法的
ret.push_back(s);// 在原字符串上修改
}
return ;
}
for(int i = startIndex;i < s.size();i++){
if(isValid(s,startIndex,i)){// 判断这个区间子串是否合法
s.insert(s.begin()+i+1,'.');// 在当前这个数字后面插入一个.
pointCount++;
backtracking(s,i+2,pointCount);// 注意，新加了一个点，所以要加2，到下一个数字
pointCount--;
s.erase(s.begin()+i+1);// 删除插入的点
}else break;//不合法直接结束
}
}
vector<string> restoreIpAddresses(string s) {
if(s.size() < 4 || s.size() > 12)return ret;// 剪枝
backtracking(s,0,0);
return ret;
}
};
- 方法1: 使用一个used数组来标记是否使用当前元素，0-暂时不考虑，1-使用，2-不使用。
class Solution {
public:
vector<int>used;// 记录是否使用过
vector<vector<int>>ret;
void backtracking(vector<int>& nums,int startIndex){
if(startIndex == nums.size()){// 到达边界出，开始收集结果
vector<int>path;
for(int i = 0; i < nums.size();i++){
if(used[i] == 1)path.push_back(nums[i]);
}
ret.push_back(path);
return;
}
// startIndex当前位置
used[startIndex] = 1;// 选当前位置
backtracking(nums,startIndex+1);
used[startIndex] = 0;// 恢复成未考虑状态
used[startIndex] = 2;// 不选当前位置
backtracking(nums,startIndex+1);
used[startIndex] = 0;// 恢复成未考虑状态
}
vector<vector<int>> subsets(vector<int>& nums) {
used.resize(nums.size(),0);
backtracking(nums,0);
return ret;
}
};
- 方法2: 相对于方法2来说，方法1更直观一些。
- 可结合下图理解，当前元素，选与不选的这个过程。
- startIndex既是边界，也是当前要操作的元素。
- 方法1，是通过使用used数组来标记当前元素(startIndex下标所对应的元素)选还是不选，最后到达边界，遍历原数组，统一收集结果path，在放入最终结果集ret中。
- 方法2，则是将选的元素直接收集进path数组中，不选了，也就是回溯，再将其pop出来，此时不断移动边界startIndex直至到达边界。到达边界后，再将小数组path放进结果集ret中。
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
void backtracking(vector<int>& nums,int startIndex){
ret.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();// 回溯-不选当前元素啦
}
}
vector<vector<int>> subsets(vector<int>& nums) {
backtracking(nums,0);
return ret;
}
};
- 开始没想明白这跟上面那个题有什么区别，我说上面那个没说不让重复不也没重吗，其实不对，因为上面那个给的数据就不是重复的，所以求子集没重复，这题给的数据出现重复的元素了，所以就需要增加一个去重操作。
相当于40题组合总和II中，我们使用的used数组，是一个意思，但是我觉得那样的意思容易让人弄混，容易直译数组名used的含义，所以我们这里将其改为int型数组，1表示当前树枝上使用了，2表示当前树层上使用了，0表示暂未考虑。
- 上方划线文字作废，就按照true表示当前树枝使用过，false表示当前树层使用过就行。
- 如下方图解所示，理解起来稍微有一点抽象，可以画图走一遍，下图仅给出第一次选1的分支。
- 仔细想一下，其实不难。
- 就是先确定一点，即，这个树枝上第一个元素，我们称为"父亲",然后再往后选剩下的每一个数，即"孩子"
- 重复的情况就是，当前这个元素上当前这个元素和前一个元素相同，并且前一个元素不是父亲元素(i > 0)，——说明，当前父亲和孩子的组合，出现过了，就是重复啦，去掉。
- 那你可能就问了，那后面也是重复的吗，当然，再往后选孩子的孩子，也是重复的。因为在上一个"树枝"已经选取过了。
- 如下图所示意:
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
vector<bool>used;
void backtracking(vector<int>&nums,int startIndex){
ret.push_back(path);// 注意本题收集结果的方式，每次递归都要收集结果。
if(startIndex == nums.size())return;// 这行可以不加
for(int i = startIndex;i < nums.size();i++){
// i > 0防止越界
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[i] = false;
path.pop_back();
}
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
sort(nums.begin(),nums.end());// 排序，用于去重
used.resize(nums.size(),false);
backtracking(nums,0);
return ret;
}
};
- 方法2: 使用下标去重，看起来更简单些，但思想同使用used数组。此方法更贴切本题中第二张图。
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
void backtracking(vector<int>&nums,int startIndex){
ret.push_back(path);
for(int i = startIndex;i < nums.size();i++){
if(i > startIndex && nums[i] == nums[i-1])continue;// 去重
path.push_back(nums[i]);
backtracking(nums,i+1);
path.pop_back();
}
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
sort(nums.begin(),nums.end());// 排序，用于去重
backtracking(nums,0);
return ret;
}
};
- 方法3: 使用set去重,去重判断同理。不做过多解释。
- 有趣的一点也是重要的一点是，注意，是先判断是出现过，然后在往set里emplace，这步就相当于使用used数组中的。可以对照理解一下。是一个意思。
if(i > 0 && nums[i] == nums[i-1] && used[i-1] == false)continue;// 去重
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
void backtracking(vector<int>&nums,int startIndex){
ret.push_back(path);
unordered_set<int>set;
for(int i = startIndex;i < nums.size();i++){
if(set.find(nums[i]) != set.end())continue;// 去重
path.push_back(nums[i]);
set.emplace(nums[i]);
backtracking(nums,i+1);
path.pop_back();
}
}
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
sort(nums.begin(),nums.end());// 排序，用于去重
backtracking(nums,0);
return ret;
}
};
本题无法像上一题那样简单的使用used数组(bool数组)进行去重。因为并不是简单的对比前一个元素，因为前一个元素不一定就可以放进去，也就是说如果(可以的话)仍使用上面used数组去重方式，逻辑会更加复杂。- 方法1: 使用set去重，同上题使用set的方法，如下图所示，不理解就跟着走一下。
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
void backtracking(vector<int>& nums,int startIndex){
// 题目要求,递增要求，至少有两个元素
if(path.size() > 1)ret.push_back(path);
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.emplace(nums[i]);
path.push_back(nums[i]);
backtracking(nums,i+1);
// 为什么这里不用将set中的元素弹出来，因为我们每次递归进来都会创建一个set。是局部变量。详情见上图所示
// 即每个set只负责本层。
path.pop_back();
}
}
vector<vector<int>> findSubsequences(vector<int>& nums) {
backtracking(nums,0);
return ret;
}
};
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
void backtracking(vector<int>& nums,int startIndex){
// 题目要求,递增要求，至少有两个元素
if(path.size() > 1)ret.push_back(path);
int used[201] = {0};// 数据范围-100到+100
for(int i = startIndex;i < nums.size();i++){
if(!path.empty() && nums[i] < path.back() ||
used[nums[i]+100] == 1)continue;
used[nums[i]+100] = 1;
path.push_back(nums[i]);
backtracking(nums,i+1);
path.pop_back();
}
}
vector<vector<int>> findSubsequences(vector<int>& nums) {
backtracking(nums,0);
return ret;
}
};
- 相对于上面使用used数组去重，本题会更好理解些，我们使用used数组，仅仅来记录当前元素是否被使用过，而且不需要indexStart来记录每层递归开始的位置，而是每次都从头开始，从而收集所有的排列方式。
- 主要的一点是，不会给重复的数，以此为去重问题，见下题。
- 给上面的补充，写在这里，每一层，是指对应树枝的下面的每一层，不是整体的每一层。
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
vector<bool>used;// 记录当前元素是否使用过，true使用过，false没使用过
void backtracking(vector<int>& nums){
if(path.size() == nums.size()){
ret.push_back(path);
return ;
}
for(int i = 0; i < nums.size() ;i++){
if(used[i] == true)continue;// 该元素已经使用过啦
path.push_back(nums[i]);
used[i] = true;
backtracking(nums);
path.pop_back();
used[i] = false;
}
}
vector<vector<int>> permute(vector<int>& nums) {
used.resize(nums.size(),false);
backtracking(nums);
return ret;
}
};
- 在上一题的基础上，给出重复的元素，需要增加去重。类似于上面求子集问题中的去重。
- 在去重逻辑中，当前元素与前一位相等，并且前一位对应used为false,去掉。
- 还是求子集问题中的去重道理。不过可以更简单的理解为，重复的数，以其为选中基准，重新排列组合出来的结果也是相同的(因为顺序固定了)。所以要去掉。——树层去重
先选中的这个数为下面树层的根。
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
vector<bool>used;// 用来记录是否使用过
void backtracking(vector<int>& nums){
if(path.size() == nums.size()){
ret.push_back(path);
return ;
}
for(int i = 0; i < nums.size();i++){
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[i] = false;// 回溯
path.pop_back();
}
}
}
vector<vector<int>> permuteUnique(vector<int>& nums) {
used.resize(nums.size(),false);
sort(nums.begin(),nums.end());
backtracking(nums);
return ret;
}
};
- 方法2： 树枝去重
即，对于树的每一个树枝来说，当我们确定了一个树层的根后，下面不可以再选与其相同的子根。
// 只需修改一步，将false改为true即可
// 如果理解了上面的我说的层的概念，这个树枝去重会很好理解。
if(i > 0 && nums[i] == nums[i-1] && used[i-1] == true)continue;
- 可以很清晰的看到，树层上对前一位去重非常彻底，效率很高，树枝上对前一位的去重虽然最后可以得到答案，但是做了很多无用搜索。
class Solution {
public:
vector<int>path;
vector<vector<int>>ret;
vector<bool>used;// 用来记录是否使用过
void backtracking(vector<int>& nums){
if(path.size() == nums.size()){
ret.push_back(path);
return ;
}
unordered_set<int>set;
for(int i = 0; i < nums.size();i++){
if(set.find(nums[i]) != set.end())continue;// 使用过了
if(used[i] == false){// 当前元素没使用，那就选上
used[i] = true;
set.insert(nums[i]);
path.push_back(nums[i]);
backtracking(nums);
used[i] = false;
path.pop_back();
}
}
}
vector<vector<int>> permuteUnique(vector<int>& nums) {
used.resize(nums.size(),false);
sort(nums.begin(),nums.end());
backtracking(nums);
return ret;
}
};
- 注意:
- 使用set去重的版本相对于used数组的版本效率会低很多。
- 因为频繁的对unordered_set进行insert操作，unordered_set需要做哈希映射(也就是把key通过hash function映射为唯一的哈希值)相对费时间，而且insert的时候其底层的符号表也要做相应的扩充，也是费时的。
class Solution {
public:
// 某一个机场可以到达的机场都有哪些，航班次数为这样的航班有几个。
// 出发机场，<到达机场，航班次数>
unordered_map<string,map<string,int>>targets;
vector<string>ret;// 收集结果,沿途经过的机场数
bool backtracking(int ticketNum){
// ret.size()当前经过的机场数量 == 航班数量+1
// 就是将所有票都用上了，终止。
if(ret.size() == ticketNum + 1)return true;// 当前票都使用完毕
//每次遍历的时候拿到上一个降落的机场，遍历这个机场接下来可以往哪飞
for(pair<const string,int>& target : targets[ret[ret.size()-1]]){// 注意传引用，修改second值，const-因为map中的key不可修改。
if(target.second > 0){//
ret.push_back(target.first);
target.second--;
if(backtracking(ticketNum))return true;// 找到了终止，就不pop出来了
ret.pop_back();// 回溯
target.second++;
}
}
return false;
}
vector<string> findItinerary(vector<vector<string>>& tickets) {
targets.clear();
for(const vector<string>& vec: tickets){// 记录映射关系-当前机场都能到哪个机场，能到达几次
targets[vec[0]][vec[1]]++;// 计数，使用了当前票--，避免死循环。
}
ret.push_back("JFK");// 起始机场
backtracking(tickets.size());
return ret;
}
};
- 时间复杂度: O ( n ! ) O(n!) O(n!)
- 空间复杂度: O ( n ) O(n) O(n),和子集问题同理
- 皇后们的要求
class Solution {
public:
vector<vector<string>>ret;
vector<string>chess_borad;
void backtracking(int n,int row){// n为棋盘大小，row为当前到第几行
if(row == n){// 每行都确定了皇后的位置
ret.push_back(chess_borad);
return ;
}
for(int col = 0; col < n;col++){
if(isValid(row,col,n)){// 当前位置合法
chess_borad[row][col] = 'Q';// 放置皇后
backtracking(n,row+1);
chess_borad[row][col] = '.';// 撤销皇后
}
}
}
// 判断当前位置放入皇后，是否合法
bool isValid(int row,int col,int n){
// 检查列
for(int i = 0; i < row;i++){
if(chess_borad[i][col] == 'Q')return false;
}
// 为什么这里没有单独检查行呢，因为递归的时候就是在调整行，递归一下，切换一下行。
// 45度——也就是往右上判断，为什么不用判断左下判断，因为还没到下面的行。
// 135度判断同理
for(int i = row - 1,j = col + 1 ;i >=0 && j < n;i--,j++){
if(chess_borad[i][j] == 'Q')return false;
}
for(int i = row - 1,j = col - 1; i >= 0 && j >= 0;i--,j--){
if(chess_borad[i][j] == 'Q')return false;
}
return true;
}
vector<vector<string>> solveNQueens(int n) {
chess_borad.resize(n,string(n,'.'));
backtracking(n,0);
return ret;
}
};
- 时间复杂度: O ( 9 m ) O(9^m) O(9m),m是’.'的数目
- 空间复杂度: O ( n 2 ) O(n^2) O(n2),递归的深度是 O ( n 2 ) O(n^2) O(n2)
- 判断棋盘是否合法
- 就是一个萝卜一个坑，理论上来说有几个空白位置就会递归几层。递归只是为了找到坑位，不会再向后移动，搜寻别的坑。详见下方注释。
class Solution {
public:
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 i = 0;i < 9;i++){// 检查同列是否有重复
if(board[i][col] == val)return false;
}
// 检查九宫格内是否有重复
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] == val)return false;
}
}
return true;
}
bool backtracking(vector<vector<char>>& board){
// 有趣的一点，我们发现在这里并没有控制下标访问，因为我们将某个空白位置放上了数字，board[i][j]就不为'.'啦，递归时就不会覆盖上一层所放的位置
// 递归的时候会不断找到空的位置，尝试放入合法的数。也就是说每次层递归，都确定一个空位置被放入一个合法的数。
// 就是一个萝卜一个坑，理论上来说有几个空白位置就会递归几层。递归只是为了找到坑位，不会再向后移动，搜寻别的坑。
// 当某一层递归中，某一个空白放哪个数字都不行，return false,回溯，尝试将上一层所放置的位置换成别的，继续调整。
for(int i = 0; i < 9;i++){
for(int j = 0; j < 9;j++){
if(board[i][j] == '.'){// 是空白
for(char k = '1' ;k <= '9';k++){// 遍历，放置合适的数字
if(isValid(i,j,k,board)){// 可以放
board[i][j] = k;
if(backtracking(board))return true;// 可以了就终止
board[i][j] = '.';
}
}
return false;// 九个数都是了，放哪个都不行，return false
}
}
}
return true;
}
void solveSudoku(vector<vector<char>>& board) {
backtracking(board);
}
};