2021-8-25 47. 全排列 II（回溯+剪枝）

注：

题目：
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列。

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

提示：
1 <= nums.length <= 8
-10 <= nums[i] <= 10

题解：
方法一 排序之后剪枝
一个比较容易想到的办法是在结果集中去重。但是问题来了，这些结果集的元素是一个又一个列表，对列表去重不像用哈希表对基本元素去重那样容易。

如果要比较两个列表是否一样，一个容易想到的办法是对列表分别排序，然后逐个比对。既然要排序，我们就可以 在搜索之前就对候选数组排序，一旦发现某个分支搜索下去可能搜索到重复的元素就停止搜索，这样结果集中不会包含重复列表。

画出树形结构如下：

重点想象深度优先遍历在这棵树上执行的过程，哪些地方遍历下去一定会产生重复，这些地方的状态的特点是什么？
对比图中标注 ① 和 ② 的地方。相同点是：这一次搜索的起点和上一次搜索的起点一样。不同点是：

1. 标注 ① 的地方上一次搜索的相同的数刚刚被撤销；
2. 标注 ② 的地方上一次搜索的相同的数刚刚被使用。

产生重复结点的地方，正是图中标注了「剪刀」，且被绿色框框住的地方。

大家也可以把第 2 个 1 加上 ’ ，即 [1, 1’, 2] 去想象这个搜索的过程。只要遇到起点一样，就有可能产生重复。这里还有一个很细节的地方：

1. 在图中 ② 处，搜索的数也和上一次一样，但是上一次的 1 还在使用中；
2. 在图中 ① 处，搜索的数也和上一次一样，但是上一次的 1 刚刚被撤销，正是因为刚被撤销，下面的搜索中还会使用到，因此会产生重复，剪掉的就应该是这样的分支。

代码实现方面，为了避免产生重复，要加上这样一段代码：

if (i > 0 && nums[i] == nums[i - 1] && !visited[i - 1]) {
    continue;
}

这段代码就能检测到标注为 ① 的两个结点，跳过它们。注意：这里 visited[i - 1] 不加 !，测评也能通过。有兴趣的朋友可以想一想这是为什么。建议大家做这样几个对比实验：

干脆就不写 !visited[i - 1] 结果是什么样？
写 !visited[i - 1] 结果是什么，代码又是怎样执行的。这里给出的结论是：!visited[i - 1] 这样的剪枝更彻底。附录会分析原因。

复杂度分析
时间复杂度：O(N×N!)，这里 N 为数组的长度。
空间复杂度：O(N×N!)。

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    void dfs(vector<int> &nums,vector<int> &visited,vector<int>& path){
        if(path.size()==nums.size()){
            res.push_back(path);
        }
        for(int i=0;i<nums.size();i++){
            //去重
            if(visited[i]==1||(i>0&&nums[i]==nums[i-1]&&visited[i-1]==0)){
                continue;
            }
            path.push_back(nums[i]);
            visited[i]=1;
            dfs(nums,visited,path);
            visited[i]=0;
            path.pop_back();
        }
        return ;
    }

    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<int> visited(nums.size(),0);
        sort(nums.begin(),nums.end());
        dfs(nums,visited,path);
        return res;
    }
};

方法二 利用set剪枝
在结果集中去重，利用set的key唯一特性存结果集，之后把set中的元素取出来，即为所求的结果
复杂度分析
时间复杂度：O(N×N!)，这里 N 为数组的长度。
空间复杂度：O(N×N!)。

class Solution {
public:
    set<vector<int>> res;
    vector<int> path;
    void dfs(vector<int> &nums,vector<int> &visited,vector<int>& path){
        if(path.size()==nums.size()){
            res.insert(path);
        }
        for(int i=0;i<nums.size();i++){
            if(visited[i]==1){
                continue;
            }
            path.push_back(nums[i]);
            visited[i]=1;
            dfs(nums,visited,path);
            visited[i]=0;
            path.pop_back();
        }
        return ;
    }

    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> ans;
        vector<int> visited(nums.size());
        fill(visited.begin(),visited.begin()+nums.size(),0);
        dfs(nums,visited,path);
        for(auto v:res){
            ans.push_back(v);
        }
        return ans;
    }
};