给你一个整数数组 nums ,数组中的元素 互不相同 。返回该数组所有可能的子集(幂集)。 解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。java
时间: 2024-04-30 15:19:55 浏览: 6
以下是Java代码实现:
```
class Solution {
public List<List<Integer>> subsets(int[] nums) {
List<List<Integer>> result = new ArrayList<>();
backtrack(result, new ArrayList<>(), nums, 0);
return result;
}
private void backtrack(List<List<Integer>> result, List<Integer> subset, int[] nums, int start) {
result.add(new ArrayList<>(subset));
for (int i = start; i < nums.length; i++) {
subset.add(nums[i]);
backtrack(result, subset, nums, i + 1);
subset.remove(subset.size() - 1);
}
}
}
```
使用回溯法来生成所有子集。我们从空集开始,每次将一个数字加入当前集合中,再递归生成子集,直到遍历完所有数字。在递归返回时,将最后一个数字从集合中移除,回溯到上一层。最终得到的所有集合即为所有子集。
相关问题
给定一组不含重复元素的整数数组nums,返回该数组所有可能的子集(幂集)
好的,您可以通过以下 Python 代码来实现该功能:
```python
class Solution:
def subsets(self, nums: List[int]) -> List[List[int]]:
res = [[]]
for num in nums:
res += [item+[num] for item in res]
return res
```
该算法的时间复杂度为O(2^n),其中n为数组的长度,因为它需要枚举所有可能的子集,空间复杂度为O(2^n),因为它需要存储所有可能的子集。
3. 给定一个可能包含重复元素的整数数组 nums,返回该数组所有可能的子集(幂集)。
可以使用回溯法来解决该问题。具体思路如下:
1. 首先将数组进行排序,这样可以避免生成重复的子集。
2. 然后定义一个辅助函数 backtrack(start, path),其中 start 表示从哪个位置开始生成子集,path 表示当前已经生成的子集。
3. 在 backtrack 函数中,首先将当前生成的子集添加到结果列表中,然后从 start 开始循环遍历数组,对于每个元素,如果它和前一个元素相同并且前一个元素没有被选择,则跳过这个元素,避免生成重复的子集;否则将这个元素加入到当前子集中,并递归调用 backtrack(start+1, path),生成以当前子集为前缀的所有子集,然后将当前子集中的这个元素移除,继续遍历数组。
4. 最后返回结果列表即可。
下面是具体的 Python 代码实现:
```python
class Solution:
def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
res = []
nums.sort()
n = len(nums)
def backtrack(start, path):
res.append(path[:])
for i in range(start, n):
if i > start and nums[i] == nums[i-1]:
continue
path.append(nums[i])
backtrack(i+1, path)
path.pop()
backtrack(0, [])
return res
```
时间复杂度为 O(2^n),其中 n 为数组长度,因为每个元素可以选择或不选择,所以总共有 2^n 种可能的组合。空间复杂度为 O(n),因为需要一个 path 数组来保存当前生成的子集。