LeetCode 47. Permutations II（有重复数字的全排列）

解题思路参考自：https://blog.csdn.net/jacky_chenjp/article/details/66477538
问题描述
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]
]

解题思路

它与全排列唯一的不同在于：在DFS函数中，做循环遍历时，如果与当前元素相同的一个元素已经被取用过，则要跳过所有值相同的元素。
  举个例子：对于序列<1,1,2,3>。在DFS首遍历时，1 作为首元素被加到list中，并进行后续元素的添加；那么，当DFS跑完第一个分支，遍历到1 (第二个)时，这个1 不再作为首元素添加到list中，因为1 作为首元素的情况已经在第一个分支中考虑过了。
  
解题算法：
  1. 先对给定的序列nums进行排序，使得大小相同的元素排在一起。
  2. 新建一个used数组，大小与nums相同，用来标记在本次DFS读取中，位置i的元素是否已经被添加到list中了。
  3. 根据思路可知，我们选择跳过一个数，当且仅当这个数与前一个数相等，并且前一个数未被添加到list中。

AC代码1

public class Solution {

    List<List<Integer>> res = new ArrayList<List<Integer>>();

    public List<List<Integer>> permuteUnique(int[] nums) {
        int len = nums.length;
        if(len==0||nums==null)  return res;

        boolean[] used = new boolean[len];
        List<Integer> list = new ArrayList<Integer>();

        Arrays.sort(nums);  //注意这一步必不可少
        dfs(nums, used, list, len);
        return res;
    }

    public void dfs(int[] nums, boolean[] used, List<Integer> list, int len) {
        if(list.size()==len) {
            res.add(new ArrayList<Integer>(list));
            return ;
        }
        for (int i=0; i<len; i++) {
            // 当前位置的数已经在List中了
            if(used[i]) continue;
            // 当前元素与其前一个元素值相同 且 前元素未被加到list中，跳过该元素
            if(i>0 && nums[i]==nums[i-1] && !used[i-1])   continue;
            // 深度优先搜索遍历
            used[i]=true;
            list.add(nums[i]);
            dfs(nums, used, list, len);
            list.remove(list.size()-1);
            used[i]=false;
        }
    }
}

AC代码2
解法和上面完全相同

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> resList = new ArrayList<>();
        if(nums == null || nums.length == 0) return resList;
        Arrays.sort(nums);
        boolean seen[] = new boolean[nums.length];
        backtrack(resList, new ArrayList<Integer>(), nums, seen);
        return resList;
    }
    
    private void backtrack(List<List<Integer>> resList, ArrayList<Integer> tmpList, int[] nums, boolean[] seen){
        if(tmpList.size() == nums.length){
            resList.add(new ArrayList(tmpList));
            return;
        }
        for(int i = 0;i < nums.length;i++){
            if(i != 0 && nums[i] == nums[i - 1] && seen[i - 1] == false || seen[i] == true) continue;
            tmpList.add(nums[i]);
            seen[i] = true;
            backtrack(resList, tmpList, nums, seen);
            tmpList.remove(tmpList.size() - 1);
            seen[i] = false;
        }
    }
}