Permutations II <LeetCode>

Given a collection of numbers that might contain duplicates, return all possible unique permutations.

For example,
[1,1,2] have the following unique permutations:
[1,1,2], [1,2,1], and [2,1,1].

 

     思路首先按照正常的DFS算法进行计算（先进行快排），当出现一个字符等于前一个数字时，有两种方法可以解决重复 1：当出现该数字等于前一个数字时，如果前一个数字已经被使用，则该数字才可以使用，相当于对相同的数字进行一定的排序，在结果中不管这些元素在哪只能按着该次序出现，因此就避免了重复。  2：第二种方法和第一种方法相反，当出现一个数字和上一个数字相等时，如果前一个数字没有被使用，则该数字才可以使用，这样如果第一个被使用的不是相同数字中的最后一个，就不会产生一个全排列，因为这个数被使用了，它后面一个相同的数字就永远不会被使用，也相当于对相同的数字进行了排序，只不过和方法1是相反的，因此也能避免重复

 

struct  tt
{
    int val;
    bool aa;
    
};

class Solution {
public:
    vector<vector<int>> result;
    vector<tt> temp;
    vector<vector<int> > permuteUnique(vector<int> &num) {
        vector<tt>  nu;
        sort(num.begin(),num.end());
        for(int i=0;i<num.size();i++)
        {
            tt t;
            t.val=num[i];
            t.aa=false;
            nu.push_back(t);
        }
        temp.clear();
        result.clear();
        getback(nu,0);
        return result;
    }
    
    void getback(vector<tt> &num,int dep)
    {
        if(dep==num.size())
        {
            vector<int>  t;
            for(int i=0;i<dep;i++)
            {
                t.push_back(temp[i].val);
            }
            result.push_back(t);

            return;
        }
        else
        {
            for(int i=0;i<num.size();i++)
            {
                if(i>0&&num[i].val==num[i-1].val&&num[i].aa==false&&num[i-1].aa==false)   //*出现相同数字时从前面的书记开始使用，  改为num[i-1].aaa==true表示从后边开始使用也可以*/
                {
                    continue;
                }
                else if(num[i].aa==false)
                {
                  num[i].aa=true;
                  temp.push_back(num[i]);
                  getback(num,dep+1);
                  temp.pop_back();
                  num[i].aa=false;
                }
            }
        }
    }
};