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]]

• 法一：下一个排列

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());
        result.push_back(nums);
        //不断调用下一个排列
        while(next_permutation(nums))
        {
            result.push_back(nums);
        }
        return result;
    }

    bool next_permutation(vector<int> &nums)
    {
        int index=nums.size()-2;
        //与没有重复元素的下一个排列唯一不同处
        //此处为前一个元素与后一个元素大于等于时index--，多了一个等于
        while(index>=0 && nums[index]>=nums[index+1])
            index--;
        if(index<0)
        {
            reverse(nums.begin(),nums.end());
            return false;
        }
        for(int i=nums.size()-1;i>index;i--)
        {
            if(nums[i]>nums[index])
            {
                swap(nums[i],nums[index]);
                reverse(nums.begin()+index+1,nums.end());
                break;
            }
        }
        return true;
    }

    
};

• 时间复杂度O(n!)
• 空间复杂度O(n)
• 思路
  • 不断调用下一个排列函数，将排列加入到结果中
  • 下一个排列
    • 将一个排列看成一个数字，所谓的下一个排列就是找相同组成下比当前数字大的最小数字。
    • 与全排列I唯一的区别在于从后往前找遇到的第一个顺序对时，是nums[index]<=nums[index+1]
    • 先从后往前找遇到的第一个顺序对，此时index指向顶点的前一个元素。再从后往前找第一个大于index指的元素，即在[index+1,end]范围内找。找到后将二者交换位置，然后将[index+1,end]的元素逆序，或者使用sort均可
• 法二：DFS

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> result;
        sort(nums.begin(),nums.end());//排序，方便去重
        vector<bool> used(nums.size(),false);
        vector<int> path;//存储一个排列
        dfs(nums,used,0,path,result);
        return result;
    }

    void dfs(const vector<int> &nums,vector<bool> &used,int index,vector<int> &path, vector<vector<int>> &result)
    {
        if(index==nums.size())
        {
            result.push_back(path);
            return;
        }
        for(int i=0;i<nums.size();i++)
        {
        	//去重方法：开始递归前先将nums排序
        	//保证相同数字都是连在一起的。每次在当前位置填数字时，对于连续相同数字，只在第一次填如
        	//used[i]==true表示当前数字已经用过了，故跳过
        	//当前数字与前一个数字相同，且前一个数字已经用过了，故跳过
            if(used[i]==true ||i>0&&used[i-1]==true&&nums[i]==nums[i-1])
                continue;
            used[i]=true;
            path.push_back(nums[i]);
            dfs(nums,used,index+1,path,result);
            used[i]=false;
            path.pop_back();
        }
    }
};

• 时间复杂度O(n!)
• 空间复杂度O(n)
• 思路
  • 依次填排列的每一位，对于重复数字，在排列的每一位只填一次。填完该位后递归填下一位，然后恢复原样。
  • 去重：开始递归前先对原数组排序，保证相同的数字都是挨在一起的。对于连续的相同数字，每次只选择第一个数字。在填第i位数字时，判断要填入的数字与nums中它的前一个数字是否相同，如果相同且前一个数字已经在该位填过一次，就跳过该数字。