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);

你可能感兴趣的:(#,回溯,#,动态规划,leetcode,java,算法)