全排列（重复值和无重复值的情况）

没有重复数值：

输入
[1,2,3]
输出
[[1,2,3],[1,3,2],[2,1,3],[2,3,1],
[3,2,1],[3,1,2]]
ans.append(nums);不加nums+[]的结果如下：
[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3],
 [1, 2, 3], [1, 2, 3]]

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        ans=[]
        def dfs(nums,start):
        //当start==arr.length-1时，说明子序列的长度为1，就不用再往下分子序列了
            if start==len(nums)-1:
            一定要加nums+[]（新建）:这个就和nums没关系了
                ans.append(nums+[]);
                return;
            for i in range(start,len(nums)):
            //start代表的是每一个子序列的第一个位置，
            我们每一层递归的任务都只有一个：
                        //枚举该层子序列第一个位置可以取的值
                nums[start],nums[i]=nums[i],nums[start];
                //该层递归的子序列第一个位置已经确定了，
                所以又可以往下再分
                dfs(nums,start+1);
                 //把第该层子序列第一个位置的值换成另外一个值，
                 所以要交换回来
                nums[start],nums[i]=nums[i],nums[start];
                
        dfs(nums,0);
        return ans;

有重复值的：

给定一个可包含重复数字的序列，返回所有不重复的全排列。

示例:

输入: [1,1,2]
输出:
[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        ans=[];
        # sorted(nums);
        canSwap=[False for _ in range(len(nums))];
        /*dfs全排列搜索前，先判断是否交换过，效率98%+*/
        def canSwap(nums,start,end):
            for i in range(start,end):
                if nums[i]==nums[end]:
                    return False;
            return True;
        def dfs(nums,start):
            if start==len(nums)-1:
                now=nums+[];
                if now not in ans:ans.append(now);
                rxeturn ;
            for i in range(start,len(nums)):
            /*dfs全排列搜索前，先判断是否交换过，效率98%+*/
                if canSwap(nums,start,i):
                    nums[start],nums[i]=nums[i],nums[start];
                    dfs(nums,start+1);
                    nums[start],nums[i]=nums[i],nums[start];
        dfs(nums,0);
        return ans;