feat: add solutions to lc/lcci problems

* lcci No.08.04 & lc No.0078.Subsets

Author: yanglbme

lcci/08.04.Power Set/README.md

@@ -29,7 +29,21 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-回溯法
+**方法一：递归枚举**
+
+我们设计一个递归函数 $dfs(u, t)$，它的参数为当前枚举到的元素的下标 $u$，以及当前的子集 $t$。
+
+当前枚举到的元素下标为 $u$，我们可以选择将其加入子集 $t$ 中，也可以选择不加入子集 $t$ 中。递归这两种选择，即可得到所有的子集。
+
+时间复杂度 $O(n\times 2^n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。数组中每个元素有两种状态，即选择或不选择，共 $2^n$ 种状态，每种状态需要 $O(n)$ 的时间来构造子集。
+
+**方法二：二进制枚举**
+
+我们可以将方法一中的递归过程改写成迭代的形式，即使用二进制枚举的方法来枚举所有的子集。
+
+我们可以使用 $2^n$ 个二进制数来表示 $n$ 个元素的所有子集，若某个二进制数 `mask` 的第 $i$ 位为 $1$，表示子集中包含数组第 $i$ 个元素 $v$；若为 $0$，表示子集中不包含数组第 $i$ 个元素 $v$。
+
+时间复杂度 $O(n\times 2^n)$，空间复杂度 $O(n)$。其中 $n$ 为数组的长度。一共有 $2^n$ 个子集，每个子集需要 $O(n)$ 的时间来构造。
 
 <!-- tabs:start -->
 
@@ -44,27 +58,39 @@ class Solution:
             if u == len(nums):
                 ans.append(t[:])
                 return
+            dfs(u + 1, t)
             t.append(nums[u])
             dfs(u + 1, t)
             t.pop()
-            dfs(u + 1, t)
 
         ans = []
         dfs(0, [])
         return ans
 ```
 
+```python
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        ans = []
+        for mask in range(1 << len(nums)):
+            t = []
+            for i, v in enumerate(nums):
+                if (mask >> i) & 1:
+                    t.append(v)
+            ans.append(t)
+        return ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
 class Solution {
-    private List<List<Integer>> ans;
+    private List<List<Integer>> ans = new ArrayList<>();
     private int[] nums;
 
     public List<List<Integer>> subsets(int[] nums) {
-        ans = new ArrayList<>();
         this.nums = nums;
         dfs(0, new ArrayList<>());
         return ans;
@@ -75,36 +101,118 @@ class Solution {
             ans.add(new ArrayList<>(t));
             return;
         }
+        dfs(u + 1, t);
         t.add(nums[u]);
         dfs(u + 1, t);
         t.remove(t.size() - 1);
-        dfs(u + 1, t);
     }
 }
 ```
 
-### **JavaScript**
-
-```js
-/**
- * @param {number[]} nums
- * @return {number[][]}
- */
-var subsets = function (nums) {
-    let prev = [];
-    let res = [];
-    dfs(nums, 0, prev, res);
-    return res;
+```java
+class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+        int n = nums.length;
+        List<List<Integer>> ans = new ArrayList<>();
+        for (int mask = 0; mask < 1 << n; ++mask) {
+            List<Integer> t = new ArrayList<>();
+            for (int i = 0; i < n; ++i) {
+                if (((mask >> i) & 1) == 1) {
+                    t.add(nums[i]);
+                }
+            }
+            ans.add(t);
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<vector<int>> subsets(vector<int>& nums) {
+        vector<vector<int>> ans;
+        vector<int> t;
+        dfs(0, nums, t, ans);
+        return ans;
+    }
+
+    void dfs(int u, vector<int>& nums, vector<int>& t, vector<vector<int>>& ans) {
+        if (u == nums.size()) {
+            ans.push_back(t);
+            return;
+        }
+        dfs(u + 1, nums, t, ans);
+        t.push_back(nums[u]);
+        dfs(u + 1, nums, t, ans);
+        t.pop_back();
+    }
 };
+```
 
-function dfs(nums, depth, prev, res) {
-    res.push(prev.slice());
-    for (let i = depth; i < nums.length; i++) {
-        prev.push(nums[i]);
-        depth++;
-        dfs(nums, depth, prev, res);
-        prev.pop();
+```cpp
+class Solution {
+public:
+    vector<vector<int>> subsets(vector<int>& nums) {
+        vector<vector<int>> ans;
+        vector<int> t;
+        int n = nums.size();
+        for (int mask = 0; mask < 1 << n; ++mask)
+        {
+            t.clear();
+            for (int i = 0; i < n; ++i)
+            {
+                if ((mask >> i) & 1)
+                {
+                    t.push_back(nums[i]);
+                }
+            }
+            ans.push_back(t);
+        }
+        return ans;
     }
+};
+```
+
+### **Go**
+
+```go
+func subsets(nums []int) [][]int {
+	var ans [][]int
+	var dfs func(u int, t []int)
+	dfs = func(u int, t []int) {
+		if u == len(nums) {
+			ans = append(ans, append([]int(nil), t...))
+			return
+		}
+		dfs(u+1, t)
+		t = append(t, nums[u])
+		dfs(u+1, t)
+		t = t[:len(t)-1]
+	}
+	var t []int
+	dfs(0, t)
+	return ans
+}
+```
+
+```go
+func subsets(nums []int) [][]int {
+	var ans [][]int
+	n := len(nums)
+	for mask := 0; mask < 1<<n; mask++ {
+		t := []int{}
+		for i, v := range nums {
+			if ((mask >> i) & 1) == 1 {
+				t = append(t, v)
+			}
+		}
+		ans = append(ans, t)
+	}
+	return ans
 }
 ```
 
@@ -122,7 +230,7 @@ function subsets(nums: number[]): number[][] {
 }
 ```
 
-```rust
+```ts
 function subsets(nums: number[]): number[][] {
     const n = nums.length;
     const res = [];
@@ -180,56 +288,6 @@ impl Solution {
 }
 ```
 
-### **C++**
-
-```cpp
-class Solution {
-public:
-    vector<vector<int>> subsets(vector<int>& nums) {
-        vector<int> t;
-        vector<vector<int>> ans;
-        dfs(0, t, nums, ans);
-        return ans;
-    }
-
-    void dfs(int u, vector<int>& t, vector<int>& nums, vector<vector<int>>& ans) {
-        if (u == nums.size()) {
-            ans.push_back(t);
-            return;
-        }
-        t.push_back(nums[u]);
-        dfs(u + 1, t, nums, ans);
-        t.pop_back();
-        dfs(u + 1, t, nums, ans);
-    }
-};
-```
-
-### **Go**
-
-```go
-func subsets(nums []int) [][]int {
-	var ans [][]int
-	var dfs func(u int, t []int)
-	dfs = func(u int, t []int) {
-		if u == len(nums) {
-			cp := make([]int, len(t))
-			copy(cp, t)
-			ans = append(ans, cp)
-			return
-		}
-		t = append(t, nums[u])
-		dfs(u+1, t)
-		t = t[:len(t)-1]
-		dfs(u+1, t)
-
-	}
-	var t []int
-	dfs(0, t)
-	return ans
-}
-```
-
 ### **...**
 
 ```