Given a collection of distinct integers, return all possible permutations.

Example:

Input: [1,2,3]
Output:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

利用回溯法來解決，考慮每一位可能出現的數字  第一位是nums所有元素都有可能，第二位是除去第一位的所有元素，用r來儲存一個臨時結果，依次考慮r的每一位，每一位都要從nums所有元素進行遍歷，當r中已有該元素時，則跳過進行下一個元素的遍歷，當len(r)==len(nums)時，將此時的r儲存到rr中，刪除r的最後一個元素，進行最後一個元素的下一種可能的遍歷。

class Solution:
    def permute(self, nums=[1,2,3]):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        rr = []
        nums.sort()
        self.backtrace(rr, [], nums)
        return rr
    
    def backtrace(self, rr, r, nums):
        if len(r)==len(nums):
            rr.append(r.copy())
            return
        for i in range(0, len(nums)):
            if nums[i] in r:
                continue
            r.append(nums[i])
            self.backtrace(rr, r, nums)
            r.pop(-1)
 

全排列的遞迴解法：

def swap(num, i, j):
    tmp = num[i]
    num[i] = num[j]
    num[j] = tmp
 
#num無重複數字 
def fullSort(num, index):
    if index==len(num)-1:
        print (num)
        return
    for i in range(index, len(num)):
        swap(num, index, i)
        fullSort(num, index+1)
        swap(num, index, i)
 

全排列的非遞迴解法：  依次產生比上一個數大的排列，直到達到最大值

#尋找比替換點大的最小數，倒序尋找，第一個大的數就是目標值 
def findBiggerThanReplaceNum(num, r):
    min = r
    for i in range(len(num)-1, r, -1):
        if num[i]>num[r]:
            return i
    return min
    
def reverse(num, i, j):
    while i<j:
        swap(num, i, j)
        i += 1
        j -= 1
        
def fullSort3(num):
    num.sort()
    print (num)
    #替換數的下標 排序完成後第一個數
    r = len(num)-1
    #替換點的下一個數座標
    m = r
    while r>0:
        m = r    
        r -= 1
        #print ('r = ', r)
        if num[r]<num[m]:
            s = findBiggerThanReplaceNum(num, r)
            #print ('s = ',s)
            swap(num, r, s)
            reverse(num, r+1, len(num)-1)
            print (num)
            #break
            r = len(num)-1

Given a collection of numbers that might contain duplicates, return all possible unique permutations.

Example:

Input: [1,1,2]
Output:
[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

求出去重的全排列：

回溯法   依次考慮每一位的取值情況，利用flag陣列來儲存nums的每一位是否使用過，第i位數字可以跳過的條件是第i位已經使用，或者nums[i]==nums[i-1]並且第i-1位使用過

class Solution:
    def permuteUnique(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        rr = []
        flag = [False for v in range(len(nums))]
        nums.sort()
        self.backtrace(rr, [], flag, nums)
        return rr
    
    def backtrace(self, rr, r, flag, nums):
        if len(r)==len(nums):
            rr.append(r.copy())
            return
        for i in range(0, len(nums)):
            if flag[i] or i>0 and nums[i-1]==nums[i] and flag[i-1]:
                continue
            r.append(nums[i])
            flag[i] = True
            print(r)
            self.backtrace(rr, r, flag, nums)
            r.pop(-1)
            flag[i] = False

遞迴解法去重：

#num中有重複數字      
def fullSort2(num, index):
    if index==len(num)-1:
        print (num)
        return
    for i in range(index, len(num)):
        #print (isSwap(num, index, i))
        if isSwap(num, index, i):
            swap(num, index, i)
            fullSort2(num, index+1)
            swap(num, index, i)

def isSwap(num, index, i):
    for j in range(index, i):
        if num[j]==num[i]:
            return False
    return True