LeetCode-90. 子集 II-Java-medium

题目链接

法一（回溯法）

public class Solution90 {

    private List<List<Integer>> ans;
    private List<Integer> path;

    /**
     * 无参构造函数
     */
    public Solution90() {
        this.ans = new LinkedList<>();
        this.path = new LinkedList<>();
    }

    /**
     * 回溯
     * used[i - 1] == true，说明同一树支candidates[i - 1]使用过
     * used[i - 1] == false，说明同一树层candidates[i - 1]使用过
     * 对于组合问题，要去重的是同一树层上的“使用过”，同一树枝上的都是一个组合里的元素，不用去重
     *
     * @param nums
     * @param start
     * @param used
     */
    private void backTracking(int[] nums, int start, boolean used[]) {
        ans.add(new LinkedList<>(path));
        for (int i = start; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) { // 跳过同一树层使用过的元素
                continue;
            }
            used[i] = true;
            path.add(nums[i]);
            backTracking(nums, i + 1, used);
            path.remove(path.size() - 1);
            used[i] = false;
        }
    }

    /**
     * 法一（回溯法）
     * 组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果
     *
     * @param nums
     * @return
     */
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        boolean used[] = new boolean[nums.length];
        Arrays.sort(nums); // 先进行排序，保证重复元素挨在一起
        backTracking(nums, 0, used);
        return ans;
    }
}

法二（动态规划）

public class Solution90 {
    /**
     * 法二（动态规划）
     * （1）确定dp数组以及下标的含义
     *      dp[i]表示前i个数的解集
     * （2）确定递推公式
     *      dp[i] = dp[i - 1] + collections(i)
     *      collections(i)表示把dp[i-1]的所有子集都加上第i个数形成的子集
     * 例如[1,2,2]，一开始解集为[[]]，表示只有一个空集
     * （1）遍历到1时，依次拷贝解集中所有子集，只有[]，把1加入拷贝的子集中得到[1]，然后加回解集中。此时解集为[[], [1]]。
     * （2）遍历到第一个2时，依次拷贝解集中所有子集，有[], [1]，把2加入拷贝的子集得到[2], [1, 2]，然后加回解集中。此时解集为
     *      [[], [1], [2], [1, 2]]。
     * （3）遍历到第二个2时，同理，此时解集为[[], [1], [2], [1, 2], *[2]*, *[1, 2]*, [2, 2], [1, 2, 2]]。
     *      *[2]*, *[1, 2]*就是第三个元素遍历以后，产生的重复部分
     *     此时，curSize = 4，lastLen = 2，从curSize - lastLen开始拷贝子集即可去重
     *
     * @param nums
     * @return
     */
    public List<List<Integer>> subsetsWithDup_2(int[] nums) {
        Arrays.sort(nums); // 先进行排序，保证重复元素挨在一起
        List<List<Integer>> dp = new ArrayList<>();
        dp.add(new ArrayList<>()); // 先将空集加入解集中
        int lastLen = 1; // 上一次没有出现重复元素时，dp的长度
        for (int i = 0; i < nums.length; i++) {
            int curSize = dp.size(); // 当前子集数
            if (i != 0 && nums[i] != nums[i - 1]) { // 更新lastLen
                lastLen = curSize;
            }
            for (int j = curSize - lastLen; j < curSize; j++) { // 从curSize - lastLen开始遍历，避免重复
                List<Integer> list = new ArrayList<>(dp.get(j)); // 拷贝子集
                list.add(nums[i]); // 向拷贝的子集中加入当前数形成新的子集
                dp.add(list);
            }
        }
        return dp;
    }
}

本地测试

        /**
         * 90. 子集 II
         */
        lay.showTitle(90);
        int[] nums90 = new int[]{1, 2, 2};
        Solution90 sol90 = new Solution90();
        List<List<Integer>> ans90_1 = sol90.subsetsWithDup(nums90);
        arrayOpt.showIntLists(ans90_1);
        System.out.println();
        List<List<Integer>> ans90_2 = sol90.subsetsWithDup_2(new int[]{4, 4, 4, 1, 4});
        arrayOpt.showIntLists(ans90_2);