LeetCode-47. 全排列 II-Java-medium

题目链接

法一

    /**
     * 回溯
     * used[i - 1] == true，说明同一树枝nums[i - 1]使用过
     * used[i - 1] == false，说明同一树层nums[i - 1]使用过
     * 如果要对树枝前一位去重用used[i - 1] == true，如果要对树层中前一位去重，就用used[i - 1] == false
     * 对于排列问题，树层上去重和树枝上去重都可以，但树层上去重效率更高
     *
     * @param ans
     * @param path
     * @param nums
     */
    private void backTracking(List<List<Integer>> ans, List<Integer> path, int[] nums, boolean used[]) {
        if (path.size() == nums.length) {
            ans.add(new LinkedList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) { // 如果nums[i]已经使用过，则直接跳过
                continue;
            }
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) { // 如果同一树层nums[i - 1]使用过则直接跳过
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            backTracking(ans, path, nums, used);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }

    /**
     * 法一（回朔法）
     * 组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果
     *
     * @param nums
     * @return
     */
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> ans = new LinkedList<>();
        List<Integer> path = new LinkedList<>();
        boolean used[] = new boolean[nums.length];
        Arrays.sort(nums); // 去重一定要对元素进行排序，这样才方便通过相邻的节点来判断是否重复使用了
        backTracking(ans, path, nums, used);
        return ans;
    }

本地测试

        /**
         * 47. 全排列 II
         */
        lay.showTitle(47);
        int[] nums47 = new int[]{1,1,2};
        Solution47 sol47 = new Solution47();
        List<List<Integer>> ans47 = sol47.permuteUnique(nums47);
        arrayOpt.showIntLists(ans47);