刷题-Leetcode-47. 全排列 II(回溯-排列[有序]-去重)

47. 全排列 II

题目链接

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/permutations-ii/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目描述

题目分析

1. 使用used去重
   
   

去重要对元素排序！！！！
树层或树枝去重都可以，树层去重效率更高

nums[i] ==nums[i- 1]时：
used[i- 1]==true 同一树枝重复
used[i- 1]==false 同一树层重复

class Solution {
//如果这个数和前面数一样
private:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums, vector<int> used){
        if(path.size() == nums.size()){
            res.push_back(path);
            return ;
        }
        for(int i = 0;i < nums.size(); i++){
            // used[i - 1] == true，说明同一树支nums[i - 1]使用过
            // used[i - 1] == false，说明同一树层nums[i - 1]使用过
            // 如果同一树层nums[i - 1]使用过则直接跳过
            if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false){//使用树层去重
            //if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == true){//树枝去重
                continue;
            }
            if(used[i] == false){
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                path.pop_back();
                used[i] = false;
            }

        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        res.clear();
        path.clear();
        sort(nums.begin(), nums.end());
        vector<int> used(nums.size(), false);
        backtracking(nums, used);
        return res;
    }
};

2. 使用set去重
   使用set效率低一些，时间复杂度高了，空间复杂度也高了。

class Solution {
//如果这个数和前面数一样
private:
    vector<vector<int>> res;
    vector<int> path;
    void backtracking(vector<int>& nums, vector<int> used){
        if(path.size() == nums.size()){
            res.push_back(path);
            return ;
        }
        unordered_set<int> uset; // 控制某一节点下的同一层元素不能重复
        for(int i = 0;i < nums.size(); i++){
            if(uset.find(nums[i]) != uset.end()){
                continue;
            }
            if(used[i] == false){
                uset.insert(nums[i]);
                used[i] = true;
                path.push_back(nums[i]);
                backtracking(nums, used);
                path.pop_back();
                used[i] = false;
            }

        }
    }
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        res.clear();
        path.clear();
        sort(nums.begin(), nums.end());
        vector<int> used(nums.size(), false);
        backtracking(nums, used);
        return res;
    }
};