6.16回溯专题（leecode491，leecode90）

491. 递增子序列

这道题目是一道绝世好题我认为，因为之前的去重逻辑在这道题并不能使用，我也卡了好久，先上代码

class Solution {
public:
    vector<int> path;
    vector<vector<int>> ans;
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        path.clear();
        ans.clear();
        if(nums.size() < 2) return ans;
        backtracking(nums, 0);
        return ans;
    }

    void backtracking(vector<int>& nums, int startindex){
        if(path.size() >= 2 ){
            ans.push_back(path);
        }

        for(int i = startindex; i < nums.size(); i++){
            //这里也要进行数层去重
            if((i > startindex && nums[i] == nums[i-1]) || (!path.empty() && nums[i] < path.back())) continue;
            else{
                path.push_back(nums[i]);
                backtracking(nums, i+1);
                path.pop_back();
            }
        }

    }
};

先看上述代码，当我用测试用例测试的时候发现了问题

我们发现用这种去重逻辑[1,3]出现了两遍，这是为什么呢？，因为我们没有对数组及逆行排序。nums[3] == nums[2]判断时我们就会重复判断。所以作者建议用unordered_map判断，这样在不排序的情况下可以实现去重！！！谨记

class Solution {
public:
    vector<int> path;
    vector<vector<int>> ans;
    vector<vector<int>> findSubsequences(vector<int>& nums) {
        path.clear();
        ans.clear();
        if(nums.size() < 2) return ans;
        backtracking(nums, 0);
        return ans;
    }

    void backtracking(vector<int>& nums, int startindex){
        if(path.size() >= 2 ){
            ans.push_back(path);
        }

        unordered_set<int> uset;
        for(int i = startindex; i < nums.size(); i++){
            //这里也要进行数层去重
            
            if((uset[nums[i]]!=0) || (!path.empty() && nums[i] < path.back())) continue;
            else{
                uset.insert(nums[i]);
                path.push_back(nums[i]);
                backtracking(nums, i+1);
                path.pop_back();
            }
        }

    }
};

90. 子集 II

class Solution {
public:
    vector<int> path;
    vector<vector<int>> ans;
    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        backtracking(nums, 0);
        return ans;

    }

    void backtracking(vector<int>& nums, int startindex){
        //因为是求子集，所以不用判断终止情况
        ans.push_back(path);

        for(int i = startindex; i < nums.size(); i++){
            if(i > startindex && nums[i] == nums[i-1]) continue;
            else{
            path.push_back(nums[i]);
            backtracking(nums, i+1);
            path.pop_back();
            }
        }
    }
};