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