LeetCode 78 子集

题目

给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。

说明：解集不能包含重复的子集。

示例:

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

思路一 回溯法（运用递归）

首先，回溯法是一种探索所有潜在可能性找到解决方案的算法。如果当前方案不是正确的解决方案，或者不是最后一个正确的解决方案，则回溯法通过修改上一步的值继续寻找解决方案。

这道题思路步骤

• 首先对数组中的每个元素，取或不取，都可以组成子集
• 遍历了整个数组，每个元素都选择取或者不取，然后向下递归，形成了一个递归二叉树

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if (nums == null) {
            return res;
        }
        dfs(res, nums, new ArrayList<>(), 0);
        return res;
    }
    public void dfs (List<List<Integer>> res, int[] nums, List<Integer> list, int index) {
        if (index == nums.length) {  //当最后一层都结束了选择，子集就可以创建了
            res.add(new ArrayList<Integer>(list));
            return;
        }
        dfs(res, nums, list, index + 1);  //不取，对list不做任何改变
        list.add(nums[index]);            //取，加入当前的数组元素
        dfs(res, nums, list, index + 1);

        list.remove(list.size() - 1);  //进行回溯，因为list是全局变量，每一层的递归中的list都会随着改变
       
}

它这个递归是先到递归二叉树的叶子节点，然后返回，这种归去来兮的感觉。从最后叶子节点返回（类似最左边的叶子节点返回），然后回来一层后，需要删除之前加入list中的数值，因为回来一层后又要进行递归，达到那一层的叶子节点。这个list需要删除前面改变的地方，这就是回溯的感觉

复杂度分析

时间复杂度：O(N×2 ^N)，生成所有子集，并复制到输出集合中。

空间复杂度：O(N×2^N)，存储所有子集，共 n个元素，每个元素都有可能存在或者不存在。

思路二，枚举

数学的思想，当每增加一个元素，相当于这个元素可以与每一个子集进行组合成为新的子集

逐个枚举，空集的幂集只有空集，每增加一个元素，让之前幂集中的每个集合，追加这个元素，就是新增的子集。

//递归
class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        if (nums == null) {
            return res;
        }
        List<Integer> a = new ArrayList<>();
        res.add(a);
        recursion(nums, 0, res);
        return res;
    }

    public void recursion(int[] nums, int index, List<List<Integer>> res) {
        if (index >= nums.length) {
            return;
        }
        int size = res.size();
        for(int i = 0; i < size; i++) {
            List<Integer> newSub = new ArrayList<Integer>(res.get(i)); 
            newSub.add(nums[index]);  //创建新的子集
            res.add(newSub);
        }
        recursion(nums, index + 1, res);
    }
}

//循环迭代
public static List<List<Integer>> enumerate(int[] nums) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        res.add(new ArrayList<Integer>());
        for (Integer n : nums) {
            int size = res.size();
            for (int i = 0; i < size; i++) {
                List<Integer> newSub = new ArrayList<Integer>(res.get(i));
                newSub.add(n);
                res.add(newSub);
            }
        }
        return res;
    }

复杂度分析

时间复杂度：O(N×2 ^N)，生成所有子集，并复制到输出结果中。

空间复杂度：O(N×2^N)，这是子集的数量。