Leetcode 78. Subsets

最新推荐文章于 2022-10-22 22:28:31 发布

Vendredimatin

最新推荐文章于 2022-10-22 22:28:31 发布

阅读量181

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.csdn.net/qq_38702697/article/details/90813226

leetcode 同时被 3 个专栏收录

67 篇文章

订阅专栏

array

33 篇文章

订阅专栏

Leetcode Array

30 篇文章

订阅专栏

本文深入探讨了生成一组不重复整数的所有可能子集（幂集）的四种方法：回溯/递归、优化后的回溯、迭代和位操作。通过实例解析，展示了不同算法的实现细节与效率对比。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Given a set of distinct integers, nums, return all possible subsets (the power set).

Note: The solution set must not contain duplicate subsets.

Example:

Input: nums = [1,2,3]
Output:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]

tag： array, backtracking,bit manipulation

method 1

使用回溯/递归的办法，list中每新添加一个数，就将它加入结果集中
subsets里面的循环是寻找递归的起点
find里面的循环是寻找第n层递归的起点，依次从前往后添加元素，以避免重复，第n层递归时，添加长度为n的子集

public List<List<Integer>> subsets(int[] nums) {
    List<List<Integer>> res = new ArrayList<>();

    res.add(new ArrayList<>());
    for (int i = 0; i < nums.length; i++) {
        List<Integer> list = new ArrayList<>();
        list.add(nums[i]);
        res.add(list);
        find(list,nums,i+1,res);
    }

    return res;
}

public void find(List<Integer> list,int[] nums, int start,List<List<Integer>> res){
    if (start == nums.length)
        return;

    for (int i = start; i < nums.length; i++) {
        List<Integer> newTmp = new ArrayList<>(list);
        newTmp.add(nums[i]);
        res.add(newTmp);
        find(new ArrayList<>(newTmp),nums,i+1,res);
    }
}

method 2

对解法一的优化，这样就少些声明，少用些空间并且简洁，和permutation一样，remove新添加的元素以避免创建新的数组

public List<List<Integer>> subsets2(int[] nums) {
    List<List<Integer>> list = new ArrayList<>();
    Arrays.sort(nums);
    backtrack(list, new ArrayList<>(), nums, 0);
    return list;
}

private void backtrack(List<List<Integer>> list , List<Integer> tempList, int [] nums, int start){
    list.add(new ArrayList<>(tempList));
    for(int i = start; i < nums.length; i++){
        tempList.add(nums[i]);
        backtrack(list, tempList, nums, i + 1);
        tempList.remove(tempList.size() - 1);
    }
}

method 3

遍历数组，每次遍历都在前一次迭代的每一个结果后面加上当前遍历的数，当然，加之前要保留之前迭代的每一个结果

public List<List<Integer>> subsets3(int[] nums) {
    List<List<Integer>> list = new ArrayList<>();
    list.add(new ArrayList<>());

    for (int num:nums) {
        int n = list.size();
        for (int i = 0; i < n; i++) {
            List<Integer> newList = new ArrayList<>(list.get(i));
            newList.add(num);
            list.add(newList);
        }
    }

    return list;
}

method 4

位操作

/**
 * 位操作，没太看得懂，留着
 *https://leetcode.com/problems/subsets/discuss/27278/C%2B%2B-RecursiveIterativeBit-Manipulation
 * @param nums
 * @return
 */
public List<List<Integer>> subsets4(int[] nums) {
    int n = nums.length;
    List<List<Integer>> subsets = new ArrayList<>();
    for (int i = 0; i < Math.pow(2, n); i++)
    {
        List<Integer> subset = new ArrayList<>();
        for (int j = 0; j < n; j++)
        {
           int tmp = (i >> j);
            int res = tmp & 1;
            if (res != 0)
                subset.add(nums[j]);
        }
        Collections.sort(subset);
        subsets.add(subset);
    }
    return subsets;
}