LeetCode 29天 回溯算法05

491. 非递减子序列

难点在于判断递增以及去重

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int>& nums, int startIndex){
        // 序列大小有要求
        if (path.size() >= 2){
            res.push_back(path);
        }
        // 存储未出现的元素
        unordered_set<int> uset;
        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) {
        path.clear();
        res.clear();
        backtracking(nums, 0);
        return res;
    }
};

46. 全排列

数组不包含重复元素，就不用去重，但是需要一个used数组记录每个数的使用情况，因为全排列中每个数只能使用一次。

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int>& nums, vector<bool> used){
        if (path.size() == nums.size()){
            res.push_back(path);
            return;
        }
        for (int i = 0; i<nums.size(); i++){
            // used记录的没有使用元素nums[i]
            if (used[i] == false){
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums,used);
                used[i] = false;
                path.pop_back();
            }
        }
    }
    vector<vector<int>> permute(vector<int>& nums) {
        res.clear();
        path.clear();
        // 初始化used数组为false
        vector<bool> used(nums.size(), false);
        backtracking(nums, used);
        return res;
    }
};

47. 全排列 II

这题与上题的差别在于数组可以有重复元素，需要去重。但是去重逻辑我没有搞懂，至少used[i-1] == false 这个是为什么我没有搞懂。

class Solution {
public:
    vector<int> path;
    vector<vector<int>> res;
    void backtracking(vector<int>& nums, vector<bool> used){
        if (path.size() == nums.size()){
            res.push_back(path);
            return;
        }
        for (int i = 0; i<nums.size(); i++){
            // used[i-1] == false 是树层上去重，used[i-1] == true 是树枝上去重
            if (i > 0 && nums[i] == nums[i-1] && used[i-1] == false)
                continue;
            // used记录的没有使用元素nums[i]
            if (used[i] == false){
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums,used);
                used[i] = false;
                path.pop_back();
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        res.clear();
        path.clear();
        // 初始化used数组为false
        vector<bool> used(nums.size(), false);
        sort(nums.begin(), nums.end());
        backtracking(nums, used);
        return res;
    }
};