回溯算法初步

第二周刷题总结
#leetcode
#回溯算法

本周主要是做了leetcode关于回溯算法的相关题目，总结了一些算法类型与答题模板。
1.答题模板
（1）先画出递归树，找到状态变量，进而推出回溯函数的参数
（2）根据题意，确立结束条件
（3）进行选择
（4）进入递归函数，注意传入的起始参数
（5）回溯
2.递归树（以子集问题为例）

3.回溯算法的题目类型及其特点

类型	特点
子集问题	无顺序、结果在递归树结点上收集
组合问题	无顺序、结果在递归树叶子节点上面收集
排列问题	有顺序、结果在递归树子节点上面收集

当然，除了上面三种基础的回溯问题外，还有切割、棋盘搜索等问题，在此暂不讨论。
4.例题
①子集
给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集），解集不能包含重复的子集。
示例:
输入: nums = [1,2,3]
输出:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]

class Solution {
public:
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<vector<int>> result;
        vector<int> path;
        backtracking(nums,result,path,0);
        return result;
    }
    
    void backtracking(vector<int>&nums,vector<vector<int>>&result,vector<int>&path,int firstIndex){
        result.push_back(path);
        for(int i=firstIndex;i<nums.size();++i){
            path.push_back(nums[i]);
            backtracking(nums,result,path,i+1);
            path.pop_back();
        }
    }
};

②子集Ⅱ
相对于上一题子集，此题给定的是一个可能包含重复元素的整数数组 nums

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& nums, vector<bool>& used,int start){
        result.push_back(path);
        for(int i=start;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,used,i+1);
            used[i] = false;
            path.pop_back();
        }
    }
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<bool> used(nums.size(),false);
        backtracking(nums,used,0);
        return result;
    }
};

③组合
给定两个整数 n 和 k，返回 1 … n 中所有可能的 k 个数的组合。
示例:
输入: n = 4, k = 2
输出:
[
[2,4],
[3,4],
[2,3],
[1,2],
[1,3],
[1,4],
]

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    vector<vector<int>> combine(int n, int k) {      
        backtracking(n,k,1);
        return result;
    }
    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();
        }
    }
};

④组合总和
给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的数字可以无限制重复被选取。
示例 1：
输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
[7],
[2,2,3]
]

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates,int target,int sum,int start){
        if(sum == target){
            result.push_back(path);
            return;
        }
        for(int i=start;i<candidates.size() && sum+candidates[i]<=target;i++){// 如果 sum + candidates[i] > target 就终止遍历
            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates,target,sum,i);
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());//首先进行一遍排序
        backtracking(candidates,target,0,0);
        return result;
    }
};

⑤组合总和Ⅱ
与上一题不同的是，candidates 中的每个数字在每个组合中只能使用一次。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void backtracking(vector<int>& candidates,int target,int sum,int start,vector<bool>& uesd){
        if(sum == target){
            result.push_back(path);
            return;
        }
        for(int i=start;i<candidates.size() && sum+candidates[i]<=target;i++){// 如果 sum + candidates[i] > target 就终止遍历
            if(i>0 && candidates[i]==candidates[i-1] && uesd[i-1]==false) continue;
            sum += candidates[i];
            path.push_back(candidates[i]);
            uesd[i] = true;
            backtracking(candidates,target,sum,i+1,uesd);
            uesd[i] = false;
            sum -= candidates[i];
            path.pop_back();
        }
    }
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        sort(candidates.begin(),candidates.end());//首先进行一遍排序
        vector<bool> uesd(candidates.size(),false);
        backtracking(candidates,target,0,0,uesd);
        return result;
    }
};

⑥全排列
给定一个 没有重复 数字的序列，返回其所有可能的全排列。
示例:
输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

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;
            used[i] = true;
            path.push_back(nums[i]);
            backtracking(nums,used);
            path.pop_back();
            used[i] = false;
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        vector<bool> used(nums.size(),false);
        backtracking(nums,used);
        return result;
    }
};

⑦全排列Ⅱ
与上一题不同，nums是一个可包含重复数字的序列。

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(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;
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        vector<bool> used(nums.size(),false);
        backtracking(nums,used);
        return result;
    }
};