LeetCode 78. 子集：

78. 子集

   

给你一个整数数组 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 中的所有元素 互不相同

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/subsets

思路：
参考：LeetCode大神题解

单看每个元素，都有两种选择：选入子集，或不选入子集。
考察当前枚举的数，基于选它而继续，是一个递归分支；基于不选它而继续，又是一个分支。
比如[1,2,3]，先看1，选1或不选1，都会再看2，选2或不选2，以此类推...

为什么要回溯？
因为不是找到一个子集就完事。
找到一个子集，结束递归，要撤销当前的选择，回到选择前的状态，做另一个选择——不选当前的数，基于不选，往下递归，继续生成子集。
回退到上一步，才能在包含解的空间树中把路走全，回溯出所有的解。

时间复杂度：
时间复杂度：O(n * 2^n)，一共 2^n 个状态，每种状态需要 O(n) 的时间来构造子集。

空间复杂度： 
O(n)，即构造子集使用的临时数组 tmpRes 的空间代价。

// 方法1 回溯
func subsets(nums []int) [][]int {
    res := make([][]int, 0)
    var dfs func(i int, subRes []int)
    dfs = func(i int, subRes []int) {
        // 如果说返回结果集为所给nums的不同全排列，则为len(nums)
        // 如果说返回结果集为所给nums的不同子集，则为len(subRes)
        if i == len(nums) { // 当遍历完nums长度后，return
            tmpRes := make([]int, len(subRes))
            copy(tmpRes, subRes)
            res = append(res, tmpRes)
            return 
        }

        // 两种情况：状态树: 追加当前第i个元素或者不追加
        // // 方式1：先不追加，然后追加：
        dfs(i + 1, subRes)  // 追加：
        subRes = append(subRes, nums[i])
        dfs(i + 1, subRes)

        // 方式2：先追加，然后回溯取消追加
        // list = append(list, nums[i])
        // dfs(i + 1, list)
        // list = list[:len(list) - 1]
        // dfs(i + 1, list)
    }
    dfs(0, []int{}) // 从第0个元素开始，触发递归；且赋值空数组

    return res
}

// 方法2 迭代
// func subsets(nums []int) [][]int {
//     result := make([][]int,0)
//     result = append(result,[]int{})
//     for i:=0;i<len(nums);i++ {
//         size := len(result)
//         for j:=0;j<size;j++ {
//             temp := make([]int,len(result[j]))
//             copy(temp,result[j])
//             temp = append(temp,nums[i])
//             result = append(result,temp)
//         }
//     }
//     return result
// }