## 题目

> - 题号：78
> - 难度：中等
> - https://leetcode-cn.com/problems/subsets/


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

<b>说明</b>：解集不能包含重复的子集。

<b>示例</b>:
```c
输入: nums = [1,2,3]
输出:
[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]
```

---
## 实现

**第一种：回溯法**

依次以nums[i]为启始点进行搜索，且后续搜索数值都要大于前一个数值，这样会避免重复搜索。

![回溯过程](https://img-blog.csdnimg.cn/20190913152245222.png)

- 状态：通过
- 10 / 10 个通过测试用例
- 行用时: 356 ms, 在所有 C# 提交中击败了 92.31% 的用户
- 内存消耗: 29.2 MB, 在所有 C# 提交中击败了 6.67% 的用户

```c
public class Solution
{
    private IList<IList<int>> _result;
    
    public IList<IList<int>> Subsets(int[] nums)
    {
        _result = new List<IList<int>>();
        int len = nums.Length;

        if (len == 0)
        {
            return _result;
        }
        IList<int> item = new List<int>();
        Find(nums, 0, item);
        return _result;
    }

    private void Find(int[] nums, int begin, IList<int> item)
    {
        // 注意：这里要 new 一下
        _result.Add(new List<int>(item)); 

        if (begin == nums.Length)
            return;

        for (int i = begin; i < nums.Length; i++)
        {
            item.Add(nums[i]);
            Find(nums, i + 1, item);

            // 组合问题，状态在递归完成后要重置
            item.RemoveAt(item.Count - 1); 
        }
    }
}
```

**第二种：子集扩展法**

- 状态：通过
- 10 / 10 个通过测试用例
- 执行用时: 352 ms, 在所有 C# 提交中击败了 94.51% 的用户
- 内存消耗: 29.2 MB, 在所有 C# 提交中击败了 6.67% 的用户

```c
public class Solution
{
    public IList<IList<int>> Subsets(int[] nums)
    {
        IList<IList<int>> result = new List<IList<int>>();
        IList<int> item = new List<int>();
        result.Add(item);
        for (int i = 0; i < nums.Length; i++)
        {
            for (int j = 0, len = result.Count; j < len; j++)
            {
                item = new List<int>(result[j]);
                item.Add(nums[i]);
                result.Add(item);
            }
        }
        return result;
    }
}
```

**第三种：位运算**

**思路：** 利用整数集合的思路。

以`{1,2,3}`为例，三个数，共`2^3`个子集。

```c
000 -> []
100 -> [1]
101 -> [1,3]
110 -> [1,2]
111 -> [1,2,3]
...
```

**C# 语言**

- 状态：通过
- 10 / 10 个通过测试用例
- 执行用时: 348 ms, 在所有 C# 提交中击败了 97.80% 的用户
- 内存消耗: 29.5 MB, 在所有 C# 提交中击败了 6.67% 的用户

```c
public class Solution
{
    public IList<IList<int>> Subsets(int[] nums)
    {
        IList<IList<int>> result = new List<IList<int>>();
        int count = nums.Length;

        for (int i = 0; i < 1 << count; i++)
        {
            IList<int> item = new List<int>();
            for (int j = 0; j < count; j++)
            {
                int mask = 1 << j;
                if ((mask & i) != 0)
                    item.Add(nums[j]);
            }
            result.Add(item);
        }
        return result;
    }
}
```

**Python 语言**

- 执行结果：通过
- 执行用时：40 ms, 在所有 Python3 提交中击败了 63.08% 的用户
- 内存消耗：13.8 MB, 在所有 Python3 提交中击败了 5.72% 的用户

```python
class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        count = len(nums)
        result = []
        for i in range(1 << count):
            item = []
            for j in range(count):
                mask = 1 << j
                if (mask & i) != 0:
                    item.append(nums[j])
            result.append(item)
        return result
```

