47. 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],
  [2,1,1]

 

1. if i > 0 and nums[i] == nums[i-1] and check[i-1] == 0
灰色为剪枝部分，蓝色为答案部分：

 

2. if i > 0 and nums[i] == nums[i-1] and check[i-1] == 1
灰色为剪枝部分，蓝色为答案部分：

 

能够明显发现第一种能够提前剪枝，减少计算步骤和搜索次数，并且第一种选择了重复元素的第一个，而第二种选择了重复元素的最后一个，虽然答案都相同，我们成年人当然是要选效率更高一些的那一种对吧~

 

class Solution:
    def __init__(self):
        self.res = []
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        
        def dfs(path,nums,level,used):
            if len(path) > len(nums):
                return
            if len(path) == len(nums):
                self.res.append(path.copy())
             
            for i in range(0,len(nums)):
                if i >=1 and nums[i] == nums[i-1] and  used[i-1]:
                    continue
                if used[i]:
                    continue
                path.append(nums[i])
                used[i] = True
                dfs(path,nums,i,used)
                path.pop()
                used[i] = False
        used = [False] * len(nums)  
        used_list = []
        nums = sorted(nums) 
        dfs([],nums,0,used)
        return self.res

 

与上一题不同，就是在19行加个判断即可。

class Solution(object):
    def __init__(self):
        self.res = []

    def permuteUnique(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        self.help(nums, 0, len(nums))

        return self.res

    def help(self, a, lo, hi):
        if(lo == hi):
            self.res.append(a[0:hi])
        for i in range(lo, hi):
            #判断 i 是否已经在当过头元素了
            if a[i] not in a[lo:i]:
                self.swap(a, i, lo)
                self.help(a, lo + 1, hi)
                self.swap(a, i, lo)
    def swap(self, a, i, j):
        temp = a[i]
        a[i] = a[j]
        a[j] = temp