力扣今日打卡之数组的全排列

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

示例:

输入: [1,1,2]
输出:
[
[1,1,2],
[1,2,1],
[2,1,1]
]
此题难度中等，比较中规中矩，我们很容易会想到递归+回溯的解法，就是用一个列表不断的去尝试并撤销，但是这里有个问题，就是去重。

    List<List<Integer>> ansList;
    public List<List<Integer>> permuteUnique(int[] nums) {
        ansList = new ArrayList<>();
        if (nums == null || nums.length == 0) return ansList;
        // 这个就是不断尝试与回溯的列表 
        List<Integer> startList = new ArrayList<>();
        // 这个记录走过的路径
        Set<Integer> traceSet = new HashSet<>();
        permuteUnique(nums, startList, traceSet);
        return ansList;
    }

    public void permuteUnique(int[] nums, List<Integer> list, Set<Integer> traceSet) {
    	// 当走过了所有的路径为递归出口
        if (traceSet.size() == nums.length) {
        	// 如果已经存在，不添加
            if (ansList.contains(list)) return ;
            ansList.add(new ArrayList<>(list));
            return ;
        }
		// 此处开始不断的尝试与回溯
        for (int i = 0;i < nums.length;i ++) {
        	// 跳过已经添加过的位置
            if (traceSet.contains(i)) continue;
            list.add(nums[i]);
            traceSet.add(i);
            permuteUnique(nums, list, traceSet);
            list.remove(list.size() - 1);
            traceSet.remove(i);
        }
    }

通过if (ansList.contains(list))来判断重复，这样执行效率很低，因为发现其中大量的重复计算。

以[1, 1, 2]为例子，对数组进行排序，三层递归去寻找，发现1和1’递归出来的结果是一样的。因此这也就是我们可以剪枝的部分。

高效率的写法：

List<List<Integer>> ansList;
	// 这里记录已经添加过的位置 
    boolean[] visited;
    public List<List<Integer>> permuteUnique(int[] nums) {
        ansList = new ArrayList<>();
        if (nums == null || nums.length == 0) return ansList;
        visited = new boolean[nums.length];
        Arrays.sort(nums); // 首先要排序
        permuteUnique(nums, new ArrayList<>());
        return ansList;
    }

    public void permuteUnique(int[] nums, List<Integer> list) {
        if (list.size() == nums.length) {
        	// 这里不再需要判断，因为都是不会重复的
            ansList.add(new ArrayList<>(list));
            return ;
        }
        for (int i = 0;i < nums.length;i ++) {
        	// 关键的剪枝逻辑，!visited[i - 1]是因为判断是回溯后的第一层剪枝,前一个节点一定是撤销了选择
            if (visited[i] || ( i > 0 && nums[i - 1] == nums[i] && !visited[i - 1])) continue;
            list.add(nums[i]);
            visited[i] = true;
            permuteUnique(nums, list);
            visited[i] = false;
            list.remove(list.size() - 1);
        }
    }