（LeetCode 46 & 47）全排列 & 全排列 II [有重复数字，去重复（添加约束条件）]

46. 全排列

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]

分析：
使用f[i]标记，记录第i个数字是否在排列中。
每次按照索引的从小到大的顺序进行判断，若第i个数不在排列中，则添加到排列中，否则判断下一个数字。
使用递归可以十分方便的实现。

AC代码：

class Solution {
public:
    int n;
    
    void qpl(int d, bool* f, vector<int>& nums, vector<int>& t, vector<vector<int>>& ans)
    {
        if(d >= n)
        {
            ans.push_back(t);
            return;
        }
        for(int i=0;i<n;i++)
        {
            if(f[i] == 0)
            {
                t[d] = nums[i];
                f[i] = 1;
                qpl(d+1,f,nums,t,ans);
                f[i] = 0;
            }
        }
    }
    
    vector<vector<int>> permute(vector<int>& nums) {
        n = nums.size();
        vector<vector<int>> ans;
        vector<int> t(n);
        bool f[n];
        memset(f,0,sizeof(f));
        qpl(0,f,nums,t,ans);
        return ans;
    }
};

47. 全排列 II

给定一个可包含重复数字的序列，返回所有不重复的全排列。

示例:

输入: [1,1,2]
输出:
[
[1,1,2],
[1,2,1],
[2,1,1]
]

分析：
与上面一题的唯一不同之处在于，在进行和上题一样的操作过程中，会产生许多重复的排列。 我们要将那些重复的排列去除。

去重复
首先，我们将数组按照升序排列，使得重复的元素彼此相邻。
以输入数组为[1,1,1,2]为例：
若不进行去重处理，我们会得到6个一样的[1,1,1,2]的结果。
这6个[1,1,1,2]的不同之处在于，他们中3个1的索引的排列顺序不同，而我们只需要这6个中的一个即可（去重，添加条件），
所以我们在排列中添加一个约束条件：重复数字（例如：3个1）的排列顺序和他们的索引的大小顺序一致。
即在[1,1,1,2]的6种情况中我们只要[1 (0),1 (1),1 (2),2]这一种（括号中是他们的索引）。

如何满足约束条件
要满足上述约束条件，换句话说，对于一段重复的数字，当我们要将其中某个数字放入到排列中时，要确保在它前面的和它一样的数字已经都进入排列中了，这样就可以保证重复数字是按照它们的索引大小顺序进入排列的，去掉了重复的排列。
也就是，在按照索引的顺序从左到右开始判断时，对于一段重复的数字，每个位置要确保它前面的一个数字已经进入了排列。

AC代码：

class Solution {
public:
    int n;
    
    void qpl(int d, bool* f, vector<int>& nums, vector<int>& t, vector<vector<int>>& ans)
    {
        if(d >= n)
        {
            ans.push_back(t);
            return;
        }
        for(int i=0;i<n;i++)
        {
            if(f[i] == 1) continue;
            if(i>0 && nums[i]==nums[i-1] && f[i-1] == 0) continue;  //确保按照索引的大小顺序排列
            t[d] = nums[i];
            f[i] = 1;
            qpl(d+1,f,nums,t,ans);
            f[i] = 0;
        }
    }
    
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        n = nums.size();
        vector<vector<int>> ans;
        vector<int> t(n);
        bool f[n];
        memset(f,0,sizeof(f));
        qpl(0,f,nums,t,ans);
        return ans;
    }
};