子集(78)力扣

最新推荐文章于 2024-09-15 15:43:59 发布

Daydreamer10

最新推荐文章于 2024-09-15 15:43:59 发布

阅读量73

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法数据结构

本文链接：https://blog.csdn.net/m0_53924828/article/details/128465307

版权

LeetCode 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

题目描述

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

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

示例 1：

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

输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

输入：nums = [0]

输出：[[],[0]]

提示：

1 <= nums.length <= 10

-10 <= nums[i] <= 10

nums 中的所有元素互不相同

扩展法(时间复杂度为O(N(2^N))，空间复杂度为O(N(2^N)))。

java实现

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        result.add(new ArrayList<>());

        for(int i:nums)
        {
            List<List<Integer>> subset=new ArrayList<>();
            for(List<Integer> list:result)
            {
                List<Integer> temp=new ArrayList<>(list);
                temp.add(i);
                subset.add(temp);
            }
            for(List<Integer> l:subset)
            {
                result.add(l);
            }
        }
        return result;
    }
}

Python实现

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        result=[[]]
        #for num in nums:
        #    result=result+[cur+[num] for cur in result]
        for num in nums:
            temp=[]
            for cur in result:
                temp.append(cur+[num])
            for t in temp:
                result.append(t)
        return result

回溯法(时间复杂度为O(N(2^N))，空间复杂度为O(N(2^N)))。

java实现

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        result.add(new ArrayList<>());
        for(int i=1;i<=nums.length;i++)
        {
            backtracking(nums,result,i,0,new ArrayList<>());
        }
        return result;
    }
    private void backtracking(int[] nums,List<List<Integer>> result,int length,int index,List<Integer> subset)
    {
        if(subset.size()==length)
        {
            result.add(new ArrayList<>(subset));
            return;
        }
        for(int i=index;i<nums.length;i++)
        {
            subset.add(nums[i]);
            backtracking(nums,result,length,i+1,subset);
            subset.remove(subset.size()-1);
        }
    }
}

Python实现

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        result=[[]]
        for i in range(1,len(nums)+1):
            self.backtracking(nums,result,i,0,[])
        return result
    
    def backtracking(self,nums,result,length,index,subset):
        if len(subset)==length:
            result.append(subset[:])
            return
        for i in range(index,len(nums)):
            subset.append(nums[i])
            self.backtracking(nums,result,length,i+1,subset)
            subset.pop()

DFS深度优先算法(时间复杂度为O(N(2^N))，空间复杂度为O(N(2^N)))。

java实现

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        dfs(nums,result,0,new ArrayList<>());
        return result;
    }

    private void dfs(int[] nums,List<List<Integer>> result,int index,ArrayList<Integer> subset)
    {
        result.add(new ArrayList<>(subset));
        if(nums.length==index)
        {
            return;
        }
        for(int i=index;i<nums.length;i++)
        {
            subset.add(nums[i]);
            dfs(nums,result,i+1,subset);
            subset.remove(subset.size()-1);
        }
    }
}

Python实现

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        result=[]
        self.dfs(nums,result,0,[])
        return result
    
    def dfs(self,nums,result,index,subset):
        result.append(subset[:])
        if index==len(nums):
            return
        for i in range(index,len(nums)):
            subset.append(nums[i])
            self.dfs(nums,result,i+1,subset)
            subset.pop()