0801回溯算法练习笔记

回溯算法

回溯法也可以叫做回溯搜索法，它是一种搜索的方式。与深度优先遍历树相似，是利用递归下探方式来解决问题的。
总体来说，不一定高效，但解决问题。在某些逻辑简单的枚举中会更高效。

递归三要素：

• 递归函数参数及返回值
• 递归终止条件
• 单层递归逻辑

算法模板：

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;
    }
};