112 lines
1.9 KiB
Markdown
112 lines
1.9 KiB
Markdown
# Leetcode Subsets
|
||
|
||
#### 2022-07-22 16:16
|
||
|
||
> ##### Algorithms:
|
||
>
|
||
> #algorithm #backtrack
|
||
>
|
||
> ##### Data structures:
|
||
>
|
||
> #DS #vector
|
||
>
|
||
> ##### Difficulty:
|
||
>
|
||
> #coding_problems #difficulty_medium
|
||
>
|
||
> ##### Additional tags:
|
||
>
|
||
> #leetcode
|
||
>
|
||
> ##### Revisions:
|
||
>
|
||
> N/A
|
||
|
||
##### Related topics:
|
||
|
||
##### Links:
|
||
|
||
- [Link to problem](https://leetcode.com/problems/subsets/)
|
||
|
||
***
|
||
|
||
### Problem
|
||
|
||
Given an integer array `nums` of **unique** elements, return _all possible subsets (the power set)_.
|
||
|
||
The solution set **must not** contain duplicate subsets. Return the solution in **any order**.
|
||
|
||
#### Examples
|
||
|
||
**Example 1:**
|
||
|
||
```
|
||
**Input:** nums = [1,2,3]
|
||
**Output:** [[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
|
||
```
|
||
|
||
**Example 2:**
|
||
|
||
```
|
||
**Input:** nums = [0]
|
||
**Output:** [[],[0]]
|
||
```
|
||
|
||
#### Constraints
|
||
|
||
- `1 <= nums.length <= 10`
|
||
- `-10 <= nums[i] <= 10`
|
||
- All the numbers of `nums` are **unique**.
|
||
|
||
### Thoughts
|
||
|
||
> [!summary]
|
||
> This is a super simple #backtrack problem.
|
||
|
||
It asked for combinations, so this is a backtrack problem.
|
||
|
||
go from index 0 to last one, in each iteration, you have two choices:
|
||
|
||
- Add this number
|
||
- Don't add this number
|
||
And we try different combinations at the same level, aka. backtracking.
|
||
|
||
#### Pseudo code:
|
||
|
||
- When loc == size, append combination to answer
|
||
- Else, start trying different solutions:
|
||
- Append this element to combs and backtrack
|
||
- pop this from combs and backtrack
|
||
|
||
### Solution
|
||
|
||
```cpp
|
||
class Solution {
|
||
vector<vector<int>> ans;
|
||
vector<int> combs;
|
||
void backtrack(vector<int> &nums, int nextLoc) {
|
||
// We don't require min amount of location
|
||
|
||
if (nextLoc == nums.size()) {
|
||
ans.push_back(combs);
|
||
} else {
|
||
combs.push_back(nums[nextLoc]);
|
||
backtrack(nums, nextLoc + 1);
|
||
|
||
combs.pop_back();
|
||
backtrack(nums, nextLoc + 1);
|
||
}
|
||
}
|
||
|
||
public:
|
||
vector<vector<int>> subsets(vector<int> &nums) {
|
||
// Backtracking for accumulating combinations.
|
||
ans = {};
|
||
combs = {};
|
||
backtrack(nums, 0);
|
||
|
||
return ans;
|
||
}
|
||
};
|
||
```
|