【蓝桥杯速成】| 11.回溯 之 子集问题

题目一：子集

问题描述

78. 子集 - 力扣（LeetCode）

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10
• nums 中的所有元素 互不相同

解题步骤

根据前面的做题经验，这一题应该比较容易AC

有没有觉得数组所有可能的子集很像我们每一层遍历的结果，

所以关于子集问题，我们需要的结果不是叶子结点，而是所有结点

那么其它代码逻辑不变，我们只需要改一下收集结果的位置即可

把result.push_back(path);这行代码从终止条件中拿出来

就表示我们每一步都会执行这一句，

空集是所有集合的子集，那么刚调用这个backtracking函数我们就会先加入[]

后面就是遍历一下就加入一下，输出顺序是纵深的，因为这里用的递归调用

对于终止条件，即用完数组所有元素，

那么我们用于指向遍历元素的startindex必然大于等于nums.size()

但其实也可以不加终止条件，因为我们的for循环会让i<nums.size(),它已经结束了

完整代码如下！

code

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums,int startindex){
        //返回的是每个结点
        result.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 result;
    }
};

---

题目二：子集②

问题描述

90. 子集 II - 力扣（LeetCode）

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

解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。

示例 1：

输入：nums = [1,2,2]
输出：[[],[1],[1,2],[1,2,2],[2],[2,2]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

提示：

• 1 <= nums.length <= 10
• -10 <= nums[i] <= 10

解题步骤

这题与上一题的区别就在于nums数组中可能包含重复元素

那么这个关键点和我们之前做过的组合总和②是一样的处理

重点就在于去重

我们需要排掉所有在同一层上相同的结果

但同时保证纵向不会被误判，因为纵向取数产生的数字重复，并不意味着答案重复

纵向是不断把子集变长的过程，加进来的都是从数组中取出的，

取出动作并不存在重复，哪怕数字一样但它不是从nums的同一位置取出的！

所以这一题我们要在单层遍历中加入去重代码即可

if(i>0 && nums[i]==nums[i-1] && used[i-1]==False)

为了方便判断重复元素，我们在主函数中会先对nums数组进行排序

那么遍历到第i个元素就可以通过 nums[i]==nums[i-1]这个代码判断是否出现重复元素

为了保证nums[i-1]合法，所以i必须大于0，

因为每次操作我们会用used数组标记数字的使用情况，

在纵向的递归中，used[i]=used[i-1]=true

但在同层当中，由于前一步存在回溯，我们的used[i-1]==false

翻译一下就是，上一层用过后放回去假装没用过

符合以上条件就是我们的重复元素，那么直接continue不需要继续执行

完整代码如下，需要注意在主函数中定义used数组和对nums数组进行排序！

code

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

---

题目三：非递减子序列

问题描述

491. 非递减子序列 - 力扣（LeetCode）

给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。

数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

示例 1：

输入：nums = [4,6,7,7]
输出：[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]

示例 2：

输入：nums = [4,4,3,2,1]
输出：[[4,4]]

提示：

• 1 <= nums.length <= 15
• -100 <= nums[i] <= 100

解题步骤

这一题可以看成上一题的升级版，它在要求不重复的情况下同时要求该子序列递增

但需要注意的是这里的子序列是按照原数组排序生成的，

我们不能使用sort函数，不然结果也是不正确的

所以我们要换一种去重逻辑

但仍旧需要做到只除去同一层的重复项

不除去纵向的重复元素

那么排序不能用，used数组也就不能用了，

我们需要一个新的辅助，对于去重首选unordered_set，

可以利用find函数很快检查到是否已经出现过

那么我们在处理这一层元素前就需要先定义好这个uset

unordered_ser<int> uset;

再进入到遍历逻辑中，挨个检查元素是否符合题意

如果该元素之前已经用过，那么它必然可以在uset中找到

所以第一个不符合的情况是

if(uset.find(nums[i])!=uset.end())

要确保子序列递增，那么nums[i]不能小于当前path的最后一个元素，即path.back()

为防止出现path为空时的错误，先判断path.empty()为false

则第二个不符合情况如下

if(!path.empty() && nums[i]<path.back)

 可以合并这两种情况，continue

没有出现以上情况，则处理该结点

把nums[i]加入uset中做记录

再加入该数到path中

递归调用后回溯

uset.insert(nums[i]);

path.push_back(nums[i]);

backtracking(nums,i+1);

path.pop_back();

这里的uset不需要回溯，因为我们在每一层使用它，

如果是递归会重新定义，内容被清空不影响判断去重 

此外在加入结果到result数组中时，我们要先判断path.size()>=2，

这也是题目条件之一，要求子序列长度大于等于2

if(path.size()>=2){

        result.push_back(path);

}

组合所有代码，即可得到完整版如下方！ 

code

class Solution {
public:
    vector<int> path;
    vector<vector<int>> result;
    void backtracking(vector<int>& nums,int startindex){
        if(path.size()>=2){
            result.push_back(path);
        }
        unordered_set<int> uset; // 使用set来对本层元素进行去重
        for(int i=startindex;i<nums.size();i++){
            if(!path.empty() && nums[i]<path.back() || uset.find(nums[i])!=uset.end())            {
                continue;
            }
            uset.insert(nums[i]);
            path.push_back(nums[i]);
            backtracking(nums,i+1);
            path.pop_back();
        }
    }
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        backtracking(nums,0);
        return result;
    }
};