leetcode():Permutations

Permutations ：
Given a collection of distinct numbers, return all possible permutations.

For example,
[1,2,3] have the following permutations:

[ [1,2,3], [1,3,2], [2,1,3], [2,3,1], [3,1,2], [3,2,1] ]

回溯法得到全排列：

java：

public static List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        dfs(result,nums,new ArrayList<Integer>());
        return result;
    }
    private static void dfs(List<List<Integer>> result, int[] nums,
            List<Integer> arrayList) {
        if(arrayList.size()==nums.length) {
            result.add(new ArrayList<>(arrayList));
            return ;
        }
        for (int i = 0; i < nums.length; i++) {
            if(arrayList.contains(nums[i])) continue;
            arrayList.add(nums[i]);
            dfs(result,nums,arrayList);
            arrayList.remove(arrayList.size()-1);
        }   
    }

python：

class Solution(object):
    def permute(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        result=[]
        self.backtrack(result,[],nums)
        return result
    def backtrack(self,result,list,nums):
        if len(list)==len(nums):
            result.append(list[:])
            return
        else:
            for i in range(len(nums)):
                if nums[i] in list:
                    continue
                else:
                    list.append(nums[i])
                self.backtrack(result,list,nums)
                list.pop()

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

java:

public List<List<Integer>> permuteUnique(int[] nums) {
    List<List<Integer>> list = new ArrayList<>();
    Arrays.sort(nums);
    backtrack(list, new ArrayList<>(), nums, new boolean[nums.length]);
    return list;
}

private void backtrack(List<List<Integer>> list, List<Integer> tempList, int [] nums, boolean [] used){
    if(tempList.size() == nums.length){
        list.add(new ArrayList<>(tempList));
    } else{
        for(int i = 0; i < nums.length; i++){
            if(used[i] || i > 0 && nums[i] == nums[i-1] && !used[i - 1]) continue;
            used[i] = true; 
            tempList.add(nums[i]);
            backtrack(list, tempList, nums, used);
            used[i] = false; 
            tempList.remove(tempList.size() - 1);
        }
    }
}

python:

class Solution(object):
    def permuteUnique(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        res, visited = [], [False]*len(nums)
        nums.sort()
        self.dfs(nums, visited, [], res)
        return res

    def dfs(self, nums, visited, path, res):
        if len(nums) == len(path):
            res.append(path)
            return 
        for i in xrange(len(nums)):
            if not visited[i]: 
                if i>0 and not visited[i-1] and nums[i] == nums[i-1]: 
                    continue
                visited[i] = True
                self.dfs(nums, visited, path+[nums[i]], res)
                visited[i] = False