回溯算法
回溯法也可以叫做回溯搜索法,它是一种搜索的方式。与深度优先遍历树相似,是利用递归下探方式来解决问题的。
总体来说,不一定高效,但解决问题。在某些逻辑简单的枚举中会更高效。
递归三要素:
- 递归函数参数及返回值
- 递归终止条件
- 单层递归逻辑
算法模板:
void backtracking(参数) {
if (终止条件) { //“不同层”逻辑
存放结果;
return;
}
//“同层”逻辑
for (选择:本层集合中元素(树中节点孩子的数量就是集合的大小)) {
处理节点;
backtracking(路径,选择列表); // 递归
回溯,撤销处理结果
}
}
全排列
题目描述
给定一个不含重复数字的数组 nums ,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。【元素要重复使用】
示例 1:
输入:nums = [1,2,3]
输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2:
输入:nums = [0,1]
输出:[[0,1],[1,0]]
示例 3:
输入:nums = [1]
输出:[[1]]
提示:
1 <= nums.length <= 6
-10 <= nums[i] <= 10
nums 中的所有整数 互不相同
代码
class Solution {
public:
vector<vector<int>> res;
vector<vector<int>> permute(vector<int>& nums) {
vector<int> tmp;
vector<int> used(nums.size(),0);
dfs(nums,tmp,0,used);
return res;
}
void dfs(vector<int>& nums,vector<int>& tmp,int pos,vector<int>& used){
if(tmp.size() == nums.size()){
res.push_back(tmp);
return;
}
for(int i = 0;i<nums.size();i++){
if(used[i]) continue;
used[i] = 1;
tmp.push_back(nums[i]);
dfs(nums,tmp,i+1,used);
tmp.pop_back();
used[i] = 0;//全排列,需要清空“用过”情况
}
}
};
组合
题目描述
求组和元素不重复使用
代码
class Solution {
public:
vector<vector<int>> res;
vector<vector<int>> combine(int n, int k) {
vector<int> tmp;
dfs(n,1,k,tmp);
return res;
}
void dfs(int n,int pos,int k,vector<int>&tmp){
if(tmp.size() == k) {//终止条件
res.push_back(tmp);//已经找到组合数对了,将结果返回到res
return;
}
for(int i = pos;i<=n-(k-tmp.size())+1;i++){//下探逻辑
tmp.push_back(i);//符合条件,存入临时记录中
dfs(n,i+1,k,tmp);
tmp.pop_back();
}
}
};
代码说明:
剪枝(只优化单层递归逻辑)
递归中循环终止条件:n-(k-tmp.size())+1
tmp.size()
是需要找到的每组组合数目前的大小(个数);则k-tmp.size()
表示这组组合数还需要几个数;下一趟循环开始的位置最早从n-(k-tmp.size())+1
处开始搜索,+1
是因为下标从零开始(或者说指针直接指的是pos
位置,需要加一才是下一轮的搜索)
组合总和
题目描述
数组元素不重复,解集中组合不能重复
代码
class Solution {
public:
vector<vector<int>> res;
vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
vector<int> tmp;
dfs(candidates,target,tmp,0);
return res;
}
void dfs(vector<int>& candidates,int target,vector<int>& tmp,int pos){
if(target < 0 || pos == candidates.size()) //输入值不合法
return;//返回到上一层
if(target == 0){//符合要求,将数写入res中
res.push_back(tmp);
return;
}
for(int i = pos;i<candidates.size();i++){
target -=candidates[i];//每次减去一个目标数,target=0时则为递归循环终止条件,将结果输出到res
tmp.push_back(candidates[i]);//将candidates[i]加入到res中
dfs(candidates,target,tmp,i);// 不用i+1了,表示可以重复读取当前的数
tmp.pop_back();
target += candidates[i];
}
}
};
剪枝之后(出现比target大的直接跳过)
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;
}
};
组合总和||
题目描述
数组元素可以重复,解集中组合不能重复
代码
class Solution {
public:
vector<vector<int>> res;
vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
//树层去重的话,需要对数组排序
sort(candidates.begin(),candidates.end());
vector<int> tmp;
vector<int> used(candidates.size(),0);
dfs(candidates,tmp,used,target,0);
return res;
}
void dfs(vector<int>& candidates,vector<int>& tmp,vector<int>& used,int target,int pos){
if(target == 0){
res.push_back(tmp);
return;
}
if(target<0 || pos == candidates.size()) return;
for(int i = pos;i<candidates.size() && target-candidates[i] >= 0;i++){
//target-candidates[i] >= 0 —— “剪枝”操作
// used[i - 1] == 1,说明同一树枝candidates[i - 1]使用过
// used[i - 1] == 0,说明同一树层candidates[i - 1]使用过
// 要对同一树层使用过的元素进行跳过
if(i>pos && candidates[i]==candidates[i-1] && used[i-1]==0) continue;
used[i] = 1;
tmp.push_back(candidates[i]);
dfs(candidates,tmp,used,target-candidates[i],i+1);//这里是i+1,每个数字在每个组合中只能使用一次
tmp.pop_back();
used[i] = 0;
}
}
};
组合总和|||
题目描述
代码
class Solution {
public:
vector<vector<int>> res;//二维数组
vector<vector<int>> combinationSum3(int k, int n) {
vector<int> tmp;
dfs(n,k,1,tmp);//1是pos,从第一个位置开始
return res;
}
void dfs(int n,int k,int pos,vector<int>& tmp){
if(n==0 && k==tmp.size()){
res.push_back(tmp);
return;
}
if(n<0 || tmp.size()>k) return;
for(int i = pos;i<=9-(k-tmp.size())+1 && n-i>=0;i++){
//n-i>=0:这一层的递归结束了,回到上面
tmp.push_back(i);
dfs(n-i,k,i+1,tmp);//从下一个位置继续
tmp.pop_back();
}
}
};
N皇后
题目描述
皇后放置要求:
- 行不相同
- 列不相同
- 对角线不相同
代码
class Solution {
public:
vector<vector<string>> res; //定义一个二维数组来存放结果
vector<vector<string>> solveNQueens(int n) {
vector<string> tmp(n,string(n,'.'));
dfs(tmp,n,0);
return res;
}
void dfs(vector<string>& tmp,int n,int row){
if(row == n){//退出条件row == n,Q在n-1行已经放完了
res.push_back(tmp);
return;//向上返回
}
for(int col = 0;col < n;col++){//当前层逻辑
if(valid(tmp,row,col)){
tmp[row][col] = 'Q';
dfs(tmp,n,row+1);
tmp[row][col] = '.';
}
}
}
//判断Q放置位置是否有效
bool valid(vector<string>& tmp,int row,int col){
for(int k = row - 1;k>=0;k--){//判断列上是否有Q
if(tmp[k][col] == 'Q')
return false;
}
for(int k = col-1;k >= 0;k--){//列变化,判断行上是否有Q
if(tmp[row][k] == 'Q')
return false;
}
//斜边判断需要两个指针一起动,判断斜方向是否有Q
for(int i = row,j = col;i >= 0 && j < tmp.size();i--,j++){
if(tmp[i][j] == 'Q')
return false;
}
for(int i = row,j = col;i >= 0 && j >= 0;i--,j--){
if(tmp[i][j] == 'Q')
return false;
}
return true;
}
};