feat: update leetcode solutions: No.0078 & No.0090

- 0078.Subsets
- 0090.Subsets II

Author: yanglbme

README.md

@@ -158,6 +158,11 @@
 - [最长上升子序列](/solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README.md)
 - [俄罗斯套娃信封问题](/solution/0300-0399/0354.Russian%20Doll%20Envelopes/README.md)
 
+### 回溯算法
+
+- [子集](/solution/0000-0099/0078.Subsets/README.md)
+- [子集 II](/solution/0000-0099/0090.Subsets%20II/README.md)
+
 ### 混合问题
 
 ### 数据库

README_EN.md

@@ -152,6 +152,11 @@ Complete solutions to [LeetCode](https://leetcode-cn.com/problemset/all/), [LCOF
 - [Longest Increasing Subsequence](/solution/0300-0399/0300.Longest%20Increasing%20Subsequence/README_EN.md)
 - [Russian Doll Envelopes](/solution/0300-0399/0354.Russian%20Doll%20Envelopes/README_EN.md)
 
+### Backtracking
+
+- [Subsets](/solution/0000-0099/0078.Subsets/README_EN.md)
+- [Subsets II](/solution/0000-0099/0090.Subsets%20II/README_EN.md)
+
 ### Misc
 
 - [Combine Two Tables](/solution/0100-0199/0175.Combine%20Two%20Tables/README_EN.md)

solution/0000-0099/0078.Subsets/README.md

@@ -28,22 +28,67 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+回溯法的基本模板：
+
+```py
+res = []
+path = []
+
+def backtrack(未探索区域, res, path):
+    if path 满足条件:
+        res.add(path) # 深度拷贝
+        # return  # 如果不用继续搜索需要 return
+    for 选择 in 未探索区域当前可能的选择:
+        if 当前选择符合要求:
+            path.add(当前选择)
+            backtrack(新的未探索区域, res, path)
+            path.pop()
+```
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        def dfs(nums, i, res, path):
+            res.append(copy.deepcopy(path))
+            while i < len(nums):
+                path.append(nums[i])
+                dfs(nums, i + 1, res, path)
+                path.pop()
+                i += 1
+        res, path = [], []
+        dfs(nums, 0, res, path)
+        return res
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+        List<Integer> path = new ArrayList<>();
+        List<List<Integer>> res = new ArrayList<>();
+        dfs(nums, 0, res, path);
+        return res;
+    }
+
+    private void dfs(int[] nums, int i, List<List<Integer>> res, List<Integer> path) {
+        res.add(new ArrayList<>(path));
+        while (i < nums.length) {
+            path.add(nums[i]);
+            dfs(nums, i + 1, res, path);
+            path.remove(path.size() - 1);
+            ++i;
+        }
+    }
+}
 ```
 
 ### **...**

solution/0000-0099/0078.Subsets/README_EN.md

@@ -43,13 +43,41 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        def dfs(nums, i, res, path):
+            res.append(copy.deepcopy(path))
+            while i < len(nums):
+                path.append(nums[i])
+                dfs(nums, i + 1, res, path)
+                path.pop()
+                i += 1
+        res, path = [], []
+        dfs(nums, 0, res, path)
+        return res
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public List<List<Integer>> subsets(int[] nums) {
+        List<Integer> path = new ArrayList<>();
+        List<List<Integer>> res = new ArrayList<>();
+        dfs(nums, 0, res, path);
+        return res;
+    }
+
+    private void dfs(int[] nums, int i, List<List<Integer>> res, List<Integer> path) {
+        res.add(new ArrayList<>(path));
+        while (i < nums.length) {
+            path.add(nums[i]);
+            dfs(nums, i + 1, res, path);
+            path.remove(path.size() - 1);
+            ++i;
+        }
+    }
+}
 ```
 
 ### **...**

solution/0000-0099/0078.Subsets/Solution.java

@@ -1,18 +1,18 @@
 class Solution {
     public List<List<Integer>> subsets(int[] nums) {
-        List<List<Integer>> list = new ArrayList<>();
-        for (int num : nums) {
-            int size = list.size();
-            for (int j = 0; j < size; j++) {
-                List<Integer> temp = new ArrayList<>(list.get(j));
-                temp.add(num);
-                list.add(temp);
-            }
-            List<Integer> one = new ArrayList<>();
-            one.add(num);
-            list.add(one);
+        List<Integer> path = new ArrayList<>();
+        List<List<Integer>> res = new ArrayList<>();
+        dfs(nums, 0, res, path);
+        return res;
+    }
+
+    private void dfs(int[] nums, int i, List<List<Integer>> res, List<Integer> path) {
+        res.add(new ArrayList<>(path));
+        while (i < nums.length) {
+            path.add(nums[i]);
+            dfs(nums, i + 1, res, path);
+            path.remove(path.size() - 1);
+            ++i;
         }
-        list.add(new ArrayList<>());
-        return list;
     }
 }

solution/0000-0099/0078.Subsets/Solution.py

@@ -0,0 +1,12 @@
+class Solution:
+    def subsets(self, nums: List[int]) -> List[List[int]]:
+        def dfs(nums, i, res, path):
+            res.append(copy.deepcopy(path))
+            while i < len(nums):
+                path.append(nums[i])
+                dfs(nums, i + 1, res, path)
+                path.pop()
+                i += 1
+        res, path = [], []
+        dfs(nums, 0, res, path)
+        return res

solution/0000-0099/0090.Subsets II/README.md

@@ -33,15 +33,48 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
+        def dfs(nums, i, res, path):
+            res.append(copy.deepcopy(path))
+            for j in range(i, len(nums)):
+                if j != i and nums[j] == nums[j - 1]:
+                    continue
+                path.append(nums[j])
+                dfs(nums, j + 1, res, path)
+                path.pop()
+        res, path = [], []
+        nums.sort()
+        dfs(nums, 0, res, path)
+        return res
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class Solution {
+    public List<List<Integer>> subsetsWithDup(int[] nums) {
+        List<Integer> path = new ArrayList<>();
+        List<List<Integer>> res = new ArrayList<>();
+        Arrays.sort(nums);
+        dfs(nums, 0, res, path);
+        return res;
+    }
+
+    private void dfs(int[] nums, int i, List<List<Integer>> res, List<Integer> path) {
+        res.add(new ArrayList<>(path));
+        for (int j = i; j < nums.length; ++j) {
+            if (j != i && nums[j] == nums[j - 1]) {
+                continue;
+            }
+            path.add(nums[j]);
+            dfs(nums, i + 1, res, path);
+            path.remove(path.size() - 1);
+        }
+    }
+}
 ```
 
 ### **...**

solution/0000-0099/0090.Subsets II/README_EN.md

@@ -41,13 +41,46 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
+        def dfs(nums, i, res, path):
+            res.append(copy.deepcopy(path))
+            for j in range(i, len(nums)):
+                if j != i and nums[j] == nums[j - 1]:
+                    continue
+                path.append(nums[j])
+                dfs(nums, j + 1, res, path)
+                path.pop()
+        res, path = [], []
+        nums.sort()
+        dfs(nums, 0, res, path)
+        return res
 ```
 
 ### **Java**
 
 ```java
-
+class Solution {
+    public List<List<Integer>> subsetsWithDup(int[] nums) {
+        List<Integer> path = new ArrayList<>();
+        List<List<Integer>> res = new ArrayList<>();
+        Arrays.sort(nums);
+        dfs(nums, 0, res, path);
+        return res;
+    }
+
+    private void dfs(int[] nums, int i, List<List<Integer>> res, List<Integer> path) {
+        res.add(new ArrayList<>(path));
+        for (int j = i; j < nums.length; ++j) {
+            if (j != i && nums[j] == nums[j - 1]) {
+                continue;
+            }
+            path.add(nums[j]);
+            dfs(nums, i + 1, res, path);
+            path.remove(path.size() - 1);
+        }
+    }
+}
 ```
 
 ### **...**

solution/0000-0099/0090.Subsets II/Solution.java

@@ -1,19 +1,21 @@
 class Solution {
     public List<List<Integer>> subsetsWithDup(int[] nums) {
+        List<Integer> path = new ArrayList<>();
         List<List<Integer>> res = new ArrayList<>();
-        if(nums==null||nums.length==0) return res;
         Arrays.sort(nums);
-        backTrack(res, nums, 0, new ArrayList<>());
+        dfs(nums, 0, res, path);
         return res;
     }
-    private void backTrack(List<List<Integer>> res, int[] nums, int index, List<Integer> ls){
-        res.add(new ArrayList<>(ls));
-        if(index>=nums.length) return;
-        for(int i=index;i<nums.length;i++){
-            ls.add(nums[i]);
-            backTrack(res, nums, i+1, ls);
-            ls.remove(ls.size()-1);
-            while(i<nums.length-1 && nums[i+1]==nums[i]) i++;
+
+    private void dfs(int[] nums, int i, List<List<Integer>> res, List<Integer> path) {
+        res.add(new ArrayList<>(path));
+        for (int j = i; j < nums.length; ++j) {
+            if (j != i && nums[j] == nums[j - 1]) {
+                continue;
+            }
+            path.add(nums[j]);
+            dfs(nums, i + 1, res, path);
+            path.remove(path.size() - 1);
         }
     }
 }

solution/0000-0099/0090.Subsets II/Solution.py

@@ -0,0 +1,14 @@
+class Solution:
+    def subsetsWithDup(self, nums: List[int]) -> List[List[int]]:
+        def dfs(nums, i, res, path):
+            res.append(copy.deepcopy(path))
+            for j in range(i, len(nums)):
+                if j != i and nums[j] == nums[j - 1]:
+                    continue
+                path.append(nums[j])
+                dfs(nums, j + 1, res, path)
+                path.pop()
+        res, path = [], []
+        nums.sort()
+        dfs(nums, 0, res, path)
+        return res