Java解子集

前言

通过子集的求法带训练将递归实现的全排列变成组合，训练观察问题解答中的规律。

一、案例

1、子集

给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。

解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。

2、示例

示例 1：

输入：nums = [1,2,3]
输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]
输出：[[],[0]]

二、题解

1、递归法

通过改进全排列实现全组合。

List<List<Integer>> res = new ArrayList<>();
    List<Integer> el = new ArrayList<>();
    Set<Integer> mark = new HashSet<>();
    int len = 0;

    //递归解法，就跟模拟法有点像，模拟取子集，往往时间复杂度高，只需要在递归上做思考，观察思考程度小。
    public List<List<Integer>> subsets(int[] nums) {

        len = nums.length;

        for (int i = 0; i <= len; i++) {
            recursion(nums, i);
        }
        return res;
    }

    private void recursion(int[] nums, int total) {

        if (el.size() == total) {
            res.add(new ArrayList<>(el));
            return;
        }
        for (int i = 0; i < len; i++) {
            if (el.size() == 0 || el.get(el.size() - 1) < nums[i] && !mark.contains(nums[i])) {
                el.add(nums[i]);
                mark.add(nums[i]);
                recursion(nums, total);
                el.remove(el.size() - 1);
                mark.remove(nums[i]);
            }
        }
    }

2、找规律

初始给一个空集，然后从前往后遍历，每遍历一个数，都加入到前面的所有子集中。

//非递归找规律，向后遍历，每次把当前遍历的数字放在前面所有子集中。
    public List<List<Integer>> subsets2(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        res.add(new ArrayList<>());

        for (int num : nums) {
            //必须先把size取出来，否则res每次add，这个res.size就会变。导致OOM
            int size = res.size();
            for (int j = 0; j < size; j++) {
                List<Integer> el = new ArrayList<>(res.get(j));
                el.add(num);
                res.add(el);
            }
        }
        return res;
    }

总结

1）循环时用容器的长度作为限制且循环体中在增删容器元素时，需注意长度是否需要提前固定，否则会出现OOM。
2）递归就像模拟法，应用递归并不难，时空复杂度一般也高，我们需要找到题解中的规律或是数学知识，实现低时空复杂度解题。

参考文献

[1]LeetCode 原题