回溯——LeetCode 子集 子集 II 递增子序列

78. 子集

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    void fun(int startIndex, const vector<int>& nums){
        ans.push_back(path);
        for(int i = startIndex; i < nums.size(); i++){
            path.push_back(nums[i]);
            fun(i + 1, nums);
            path.pop_back();
        }
    }

    vector<vector<int>> subsets(vector<int>& nums) {
        fun(0, nums);
        return ans;
    }
};

90. 子集 II

由于是求子集，不要求返回子集中数字的顺序，可以对原数组进行排序

排序以后，横向去重即可，横向去重时，值得注意的是，同一树层重复时，used[i-1]=false，同一树枝重复时，used[i-1]=true，

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;
    vector<bool> used;

    void func(int startIndex, const vector<int>& nums){
        ans.push_back(path);
        for(int i = startIndex; i < nums.size(); i++){
            if(i > startIndex && nums[i] == nums[i-1] && !used[i-1]){
                // 同一树层，不出现重复的元素，同一树层不使用重复元素，都是i > startIndex
                continue;
            }
            used[i] = true;
            path.push_back(nums[i]);
            func(i + 1, nums);
            path.pop_back();
            used[i] = false;
        }
    }

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        used.resize(nums.size());
        sort(nums.begin(), nums.end());
        func(0, nums);
        return ans;
    }
};

491. 递增子序列

由于求子序列，不能对原数组排序，比如数组[4,6,7,6]，如果排序，我们就会找出子序列[4,6,6,7]，但题目要求我们在原数组中找出递增子序列，如果是在原数组中找递增子序列，就不应该出现[4,6,6,7]，所以不能排序

由于不能排序，我们不能使用子集 II中的方式进行去重，因为相同的元素不一样相邻，不能通过used[i-1]进行去重，需要用哈希表记录当前树层使用过的元素

这题需要注意以下点：

• 横向限制：同一树层不能出现相同的数字
• 纵向限制：同一树枝往下深入时，不能出现孩子节点比父亲大的情况

class Solution {
public:
    vector<vector<int>> ans;
    vector<int> path;

    void func(int startIndex, const vector<int>& nums){
        if(path.size() > 1){
            ans.push_back(path);
        }
        // 改用哈希表去重，而不用数组
        // used不能是全局变量，used只用来记录当前树层使用过的元素
        unordered_set<int> used;
        for(int i = startIndex; i < nums.size(); i++){
            if(i > startIndex && used.find(nums[i]) != used.end()){
                // 横向限制，同一树层，不能出现相同的数字
                continue;
            }
            if(!path.empty() && nums[i] < path.back()){
                // 纵向限制，不能比前面使用过的小
                continue;
            }
            used.insert(nums[i]);
            path.push_back(nums[i]);
            func(i + 1, nums);
            path.pop_back();
        }
    }

    vector<vector<int>> findSubsequences(vector<int>& nums) {
        func(0, nums);
        return ans;
    }
};