Leetcode刷题笔记（C++）——回溯法

Leetcode刷题笔记（C++）——回溯法

整理一下刷题过程中的思路，在这里进行一下总结与分享。
github地址：https://github.com/lvjian0706/Leetcode-solutions
github项目是刚刚新建的，陆续会将整理的代码以及思路上传上去，代码是基于C++与python的。同时会将基础的排序算法等也一并进行整理上传。

39. 组合总和

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：
所有数字（包括 target）都是正整数。
解集不能包含重复的组合。

示例 1：
输入：candidates = [2,3,6,7], target = 7,
所求解集为：
[
[7],
[2,2,3]
]
示例 2：
输入：candidates = [2,3,5], target = 8,
所求解集为：
[
[2,2,2,2],
[2,3,3],
[3,5]
]

class Solution {
    
    
public:
    /*
    1. 当当前组合的和大于target时，直接return，等于target时，将组合push到最终答案中；
    2. 为了避免重复组合的情况，定义变量i用于记录当前遍历到了哪个元素，之前的元素不再重复遍历；
    3. 从第i个元素开始遍历，套用回溯算法模板，将当前元素push到组合中，sum加上当前元素，继续递归；
    4. 在组合中删除当前元素，sum减去当前元素后遍历i+1个元素；
    */
    void backtrack(vector<int>& candidates, int target, int i, int& sum, vector<vector<int>>& ans, vector<int>& sub_ans){
    
    
        if(sum>target) return;
        if(sum==target){
    
    
            ans.push_back(sub_ans);
            return;
        }
        for(int j=i; j<candidates.size(); j++){
    
    
            sub_ans.push_back(candidates[j]);
            sum += candidates[j];
            backtrack(candidates, target, j, sum, ans, sub_ans);
            sub_ans.pop_back();
            sum -= candidates[j];
        }
    }

    /*
    统计所有可能的排列情况：回溯算法
    1. 新建一维数组存储每个组合，新建二维数组存储最终结果；
    2. 找出 candidates 中所有可以使数字和为 target 的组合，所以定义sum变量用于存储当前组合的和；
    3. 递归遍历数组，不断计算符合条件的组合并push到答案中；
    */
    vector<vector<int>> combinationSum(vector<int>& candidates, int target) {
    
    
        vector<vector<int>> ans;
        vector<int> sub_ans;
        int sum = 0;
        backtrack(candidates, target, 0, sum, ans, sub_ans);
        return ans;
    }
};

46. 全排列

给定一个 没有重复 数字的序列，返回其所有可能的全排列。

示例:
输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

class Solution {
    
    
public:
    /*
    回溯思想：
    1. 当sub_ans中元素个数为nums中的元素个数时，保存；
    2. 循环遍历当前层，将遍历到的元素push进子集中；
    3. 将遍历到的元素添加到set中；
    4. 递归遍历更深层；
    5. 将该数在set中删除；
    6. 将该数去掉后继续遍历当前层；
    */
    void backtrack(vector<int>& nums, vector<int>& sub_ans, vector<vector<int>>& ans, set<int>& Set){
    
    
        if(sub_ans.size() == nums.size()){
    
    
            ans.push_back(sub_ans);
            return;
        }
        for(int i=0; i<nums.size(); i++){
    
    
            if(Set.find(nums[i])==Set.end()){
    
    
                sub_ans.push_back(nums[i]);
                Set.insert(nums[i]);
                backtrack(nums, sub_ans, ans, Set);
                Set.erase(nums[i]);
                sub_ans.pop_back();
            }
        }
    }

    /*
    所有可能的全排列：使用回溯算法，类似树的遍历
    要返回所有全排列，因此应该建立一个二位数组存放答案，其中每个1维数组是各个全排列；
    其中，为了避免全排列中包含相同元素，定义set用来记录已经遍历的元素；
    1. 递归遍历数组，不断计算新全排列并push到答案中；
    */
    vector<vector<int>> permute(vector<int>& nums) {
    
    
        vector<int> sub_ans;
        vector<vector<int>> ans;
        set<int> Set;
        backtrack(nums, sub_ans, ans, Set);
        return ans;
    }
};

78. 子集

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:
输入: nums = [1,2,3]
输出:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]

class Solution {
    
    
public:
    /*
    回溯思想：
    1. 结束条件是遍历到了数组末尾；
    2. 每遍历到一个数，push进子集，并将子集push到答案中；
    3. 继续递归遍历；
    4. 将该数去掉后继续遍历；
    */
    void backtrack(vector<int>& nums, int i, vector<int>& sub_ans, vector<vector<int>>& ans){
    
    
        if(i>nums.size()-1) return;
        sub_ans.push_back(nums[i]);
        ans.push_back(sub_ans);
        backtrack(nums, i+1, sub_ans, ans);
        sub_ans.pop_back();
        backtrack(nums, i+1, sub_ans, ans);
    }

    /*
    穷尽所有可能：使用回溯算法，类似树的遍历
    要返回所有子集，因此应该建立一个二位数组存放答案，其中每个1维数组是各个子集；
    1. 先保存空子集；
    2. 递归遍历数组，不断计算新子集并push到答案中；
    */
    vector<vector<int>> subsets(vector<int>& nums) {
    
    
        vector<vector<int>> ans;
        vector<int> sub_ans;
        ans.push_back(sub_ans);
        backtrack(nums, 0, sub_ans, ans);
        return ans;
    }
};

方法2：
class Solution {
    
    
public:
    /*
    回溯思想：
    1. 保存子集；
    2. 结束条件是遍历到了数组末尾；
    3. 循环遍历当前层，将遍历到的元素push进子集中；
    4. 递归遍历更深层；
    5. 将该数去掉后继续遍历当前层；
    */
    void backtrack(vector<int>& nums, int i, vector<int>& sub_ans, vector<vector<int>>& ans){
    
    
        ans.push_back(sub_ans);
        if(i==nums.size()) return;
        for(int j=i; j<nums.size(); j++){
    
    
            sub_ans.push_back(nums[j]);
            backtrack(nums, j+1, sub_ans, ans);
            sub_ans.pop_back();
        }
    }

    /*
    穷尽所有可能：使用回溯算法，类似树的遍历
    要返回所有子集，因此应该建立一个二位数组存放答案，其中每个1维数组是各个子集；
    1. 递归遍历数组，不断计算新子集并push到答案中；
    */
    vector<vector<int>> subsets(vector<int>& nums) {
    
    
        vector<int> sub_ans;
        vector<vector<int>> ans;
        backtrack(nums, 0, sub_ans, ans);
        return ans;
    }
};

90. 子集 II

给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:
输入: [1,2,2]
输出:
[
[2],
[1],
[1,2,2],
[2,2],
[1,2],
[]
]

class Solution {
    
    
public:
    /*
    回溯思想：
    1. 结束条件是遍历到了数组末尾；
    2. 每遍历到一个数，push进子集，
    3. 判断Set中是否存在该子集，如果不存在将子集push到答案中，并将子集insert到Set中；
    4. 继续递归遍历；
    5. 将该数去掉后继续遍历；
    */
    void backtrack(vector<int>& nums, int i, vector<int>& sub_ans, vector<vector<int>>& ans, set<vector<int>>& Set){
    
    
        if(i>nums.size()-1) return;
        sub_ans.push_back(nums[i]);
        if(Set.find(sub_ans)==Set.end()){
    
    
            ans.push_back(sub_ans);
            Set.insert(sub_ans);
        }
        backtrack(nums, i+1, sub_ans, ans, Set);
        sub_ans.pop_back();
        backtrack(nums, i+1, sub_ans, ans, Set);
    }

    /*
    穷尽所有可能：使用回溯算法，类似树的遍历，其中，需要注意数组有重复元素，但是答案不能包含重复子集
    要返回所有子集，因此应该建立一个二位数组存放答案，其中每个1维数组是各个子集；
    对于不能包含重复子集的情况，使用Set存储子集，用于判断是否重复
    1. 先保存空子集；
    2. 递归遍历数组，不断计算新子集并push到答案中，其中使用Set存储子集，用于判断是否重复；
    */
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
    
    
        sort(nums.begin(), nums.end());
        vector<int> sub_ans;
        vector<vector<int>> ans;
        ans.push_back(sub_ans);
        set<vector<int>> Set;
        backtrack(nums, 0, sub_ans, ans, Set);
        return ans;
    }
};

方法2：

class Solution {
    
    
public:
    /*
    回溯思想：
    1. 保存子集；
    2. 结束条件是遍历到了数组末尾；
    3. 循环遍历当前层，当元素不为重复元素时，将遍历到的元素push进子集中；
    4. 递归遍历更深层；
    5. 将该数去掉后继续遍历当前层；
    */
    void backtrack(vector<int>& nums, int i, vector<int>& sub_ans, vector<vector<int>>& ans){
    
    
        ans.push_back(sub_ans);
        if(i==nums.size()) return;
        for(int j=i; j<nums.size(); j++){
    
    
            if(j>i && nums[j]==nums[j-1]) continue;
            sub_ans.push_back(nums[j]);
            backtrack(nums, j+1, sub_ans, ans);
            sub_ans.pop_back();
        }
    }

    /*
    穷尽所有可能：使用回溯算法，类似树的遍历
    要返回所有子集，因此应该建立一个二位数组存放答案，其中每个1维数组是各个子集；
    1. 递归遍历数组，不断计算新子集并push到答案中；
    */
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
    
    
        sort(nums.begin(), nums.end());
        vector<int> sub_ans;
        vector<vector<int>> ans;
        backtrack(nums, 0, sub_ans, ans);
        return ans;
    }
};