LeetCode 题解（107）: Permutations II

题目：

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

题解：

先对原数列排序，再用求next permutation的方法来避免duplicate，把所有permutation加入results只到meet最大的permutation。

C++版：

class Solution {
public:
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        vector<vector<int>> results;
        if(nums.size() == 0)
            return results;
        sort(nums.begin(), nums.end());
        results.push_back(nums);
        while(hasNextPermutation(nums))
            results.push_back(nums);
        return results;
    }
    
    bool hasNextPermutation(vector<int>& nums) {
        auto i = nums.end() - 2;
        while(i >= nums.begin()) {
            if(*i < *(i+1)) 
                break;
            i--;
        }
        if(i >= nums.begin()) {
            auto j = nums.end() - 1;
            while(*j <= *i)
                j--;
            iter_swap(i, j);
            sort(i+1, nums.end());
            return true;
        }
        return false;
    }
};

Java版：

public class Solution { 
    
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if(nums.length == 0)
            return results;
        List<Integer> result = new ArrayList<>();
        for(int i : nums)
            result.add(i);
        Collections.sort(result);
        results.add(result);
        List<Integer> temp = new ArrayList<>();
        temp.addAll(result);
        while(hasNextPermutation(temp))  {
            List<Integer> temp1 = new ArrayList<>();
            temp1.addAll(temp);
            results.add(temp1);
        }
        return results;
    }
    
    public boolean hasNextPermutation(List<Integer> nums) {
        int i = nums.size() - 2;
        while(i >= 0) {
            if(nums.get(i) < nums.get(i+1))
                break;
            i--;
        }
        if(i >= 0) {
            int j = nums.size() - 1;
            while(nums.get(j) <= nums.get(i))
                j--;
            int temp = nums.get(i);
            nums.set(i, nums.get(j));
            nums.set(j, temp);
            int start = i + 1;
            int end = nums.size() - 1;
            while(start <= end) {
                int t = nums.get(start);
                nums.set(start, nums.get(end));
                nums.set(end, t);
                start++;
                end--;
            }
            return true;
        }
        return false;
    }
}

Python版：

import copy

class Solution:
    # @param {integer[]} nums
    # @return {integer[][]}
    def permuteUnique(self, nums):
        results = []
        if len(nums) == 0:
            return results
        nums.sort()
        results.append(copy.copy(nums))
        while self.hasNextPermutation(nums):
            cur = copy.copy(nums)
            results.append(cur)
        return results
        
    def hasNextPermutation(self, nums):
        i = len(nums) - 2
        while i >= 0:
            if nums[i] < nums[i+1]:
                break
            i -= 1
        
        if i >= 0:
            j = len(nums) - 1
            while nums[j] <= nums[i]:
                j -= 1
            temp = nums[i]
            nums[i] = nums[j]
            nums[j] = temp
            nums[i+1:] = reversed(nums[i+1:])
            return True
        return False