LeetCode47-全排列2

Leetcode / 力扣

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

直接搜索，由于包含重复数，用map去重
代码如下：

class Solution {
    vector >ans;
    vectorvis;
    map,int>mp;
    int len;

    void dfs(vector& nums,int loc,vector& a) {
        if(loc==len) {
            if(mp[a]==0) {
                ans.push_back(a);
                mp[a]=1;
            }
            return ;
        }

        for(int i=0;i> permuteUnique(vector& nums) {
        sort(nums.begin(),nums.end());
        len=nums.size();
        ans.clear();
        mp.clear();
        vis.assign(len,0);

        vectora;
        dfs(nums,0,a);
        return ans;
    }
};

上面的搜索用于使用map去重，时间和空间使用较大，我们可以考虑优化。
由于包含重复数，每个位置枚举搜索时需要判断这个数是否在这个位置已经枚举过。
我们可以先对数组排序，那么数字相同的数都会在一起，排序之后一定是从左往右以此填入数值，如果挨着的两个相等，并且前面那个没有被用过，说明上次循环就已经用这个数填过该位置了
代码如下：

class Solution {
    vector >ans;
    vectorvis;
    int len;

    void dfs(vector& nums,int loc,vector& a) {
        if(loc==len) {
            ans.push_back(a);
            return ;
        }

        for(int i=0;i0 && nums[i]==nums[i-1] && !vis[i-1])  //排序之后一定是从左往右以此填入数值，如果挨着的两个相等，并且前面那个没有被用过，说明上次循环就已经用这个数填过该位置了
                continue;
            if(vis[i]==0) {
                a.push_back(nums[i]);
                vis[i]=1;
                dfs(nums,loc+1,a);
                vis[i]=0;
                a.pop_back();
            }
        }
    }

public:
    vector> permuteUnique(vector& nums) {
        sort(nums.begin(),nums.end());
        len=nums.size();
        ans.clear();
        vis.assign(len,0);

        vectora;
        dfs(nums,0,a);
        return ans;
    }
};

排序之后进行全排列，不知道怎么手写全排列的可以写一下这个题leetcode31-下一个排列
leetcode31题解
这道题代码如下：

class Solution {
    int nextPermutation(vector& nums) {
        int len=nums.size();
        
        //找到第一个尽量靠右的一个较小的数，能够和后面的数进行交换
        int i=len-2;
        while(i>=0 && nums[i]>=nums[i+1]) --i;
        
        if(i==-1) {     //完全逆序，一个排列是正序，结束排序
            reverse(nums.begin(),nums.end());
            return 0;
        }
        
        //找到后面第一个大于等于nums[i]的数进行交换
        int j=len-1;
        while(j>=0 && nums[j]<=nums[i]) --j;
        swap(nums[i],nums[j]);
        reverse(nums.begin()+i+1,nums.end());
        return 1;
    }
public:
    vector> permuteUnique(vector& nums) {
        sort(nums.begin(),nums.end());
        vector>ans;
        do{
            ans.push_back(nums);
        }while(nextPermutation(nums));
        return ans;
    }
};

用全排列库函数next_permutation()
代码如下：

class Solution {
public:
    vector> permuteUnique(vector& nums) {
        sort(nums.begin(),nums.end());
        vector >ans;
        do {
            ans.push_back(nums);
        }while(next_permutation(nums.begin(),nums.end()));
        return ans;
    }
};