Leetcode46: 全排列

Leetcode46: Permutations
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中的每个字符，以当前字符作为新list的首字符，用递归往里面填充字符，当新List的长度与nums长度相等时，导入output中，具体看代码：

class Solution:
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        length = len(nums)
        if length == 0:
            return []
        def dfs(nums,sublen,current,output):
            if sublen==length:
                output.append(current)
            else:
                for num in nums:
                    if num not in current:
                        dfs(nums,sublen+1,current+[num],output)
        output=[]
        dfs(nums,0,[],output)
        return output

但是，上面那种解法虽然简洁，但是没有考虑字符重复的情况。
接下来使用剑指Offer提供的思路来解决问题，同时处理字符重复的情况：

class Solution:
    def Permutation(self, ss):
        if len(ss)==0:
            return []
        if len(ss)==1:
            return [ss]
        output = []
        ss = [s for s in ss]
        j = 0
        def dfs(ss,j,output):
            if len(ss)-1==j:
                output.append(ss[:])
            for i in range(j,len(ss)):
                if i!=j and ss[i]==ss[j]:
                    continue
                temp = ss[j]
                ss[j] = ss[i]
                ss[i] = temp
                dfs(ss,j+1,output)
                temp = ss[j]
                ss[j] = ss[i]
                ss[i] = temp
        dfs(ss,j,output)
        output = [''.join(out) for out in output]
        output.sort()
        return output