Skip to content

Commit af57149

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0491
No.0491.Increasing Subsequences
1 parent bc6fefa commit af57149

File tree

6 files changed

+307
-2
lines changed

6 files changed

+307
-2
lines changed

‎solution/0400-0499/0491.Increasing Subsequences/README.md

Lines changed: 110 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -39,22 +39,131 @@
3939

4040
<!-- 这里可写通用的实现逻辑 -->
4141

42+
**方法一：DFS**
43+
44+
DFS 递归枚举每个数字选中或不选中，这里需要满足两个条件：
45+
46+
1. 子序列需要递增（非严格递增），因此序列的后一个数要大于等于前一个数；
47+
1. 子序列需要去重，这里重复的问题在于前后两个数相等并且不选中的情况，我们只在前后两个数不等的情况下，执行不选中的操作即可达到去重的效果。
48+
4249
<!-- tabs:start -->
4350

4451
### **Python3**
4552

4653
<!-- 这里可写当前语言的特殊实现逻辑 -->
4754

4855
```python
49-
56+
class Solution:
57+
def findSubsequences(self, nums: List[int]) -> List[List[int]]:
58+
def dfs(u, last, t):
59+
if u == len(nums):
60+
if len(t) > 1:
61+
ans.append(t[:])
62+
return
63+
if nums[u] >= last:
64+
t.append(nums[u])
65+
dfs(u + 1, nums[u], t)
66+
t.pop()
67+
if nums[u] != last:
68+
dfs(u + 1, last, t)
69+
70+
ans = []
71+
dfs(0, -1000, [])
72+
return ans
5073
```
5174

5275
### **Java**
5376

5477
<!-- 这里可写当前语言的特殊实现逻辑 -->
5578

5679
```java
80+
class Solution {
81+
private int[] nums;
82+
private List<List<Integer>> ans;
83+
84+
public List<List<Integer>> findSubsequences(int[] nums) {
85+
this.nums = nums;
86+
ans = new ArrayList<>();
87+
dfs(0, -1000, new ArrayList<>());
88+
return ans;
89+
}
90+
91+
private void dfs(int u, int last, List<Integer> t) {
92+
if (u == nums.length) {
93+
if (t.size() > 1) {
94+
ans.add(new ArrayList<>(t));
95+
}
96+
return;
97+
}
98+
if (nums[u] >= last) {
99+
t.add(nums[u]);
100+
dfs(u + 1, nums[u], t);
101+
t.remove(t.size() - 1);
102+
}
103+
if (nums[u] != last) {
104+
dfs(u + 1, last, t);
105+
}
106+
}
107+
}
108+
```
109+
110+
### **C++**
111+
112+
```cpp
113+
class Solution {
114+
public:
115+
vector<vector<int>> findSubsequences(vector<int>& nums) {
116+
vector<vector<int>> ans;
117+
vector<int> t;
118+
dfs(0, -1000, t, nums, ans);
119+
return ans;
120+
}
121+
122+
void dfs(int u, int last, vector<int>& t, vector<int>& nums, vector<vector<int>>& ans) {
123+
if (u == nums.size())
124+
{
125+
if (t.size() > 1) ans.push_back(t);
126+
return;
127+
}
128+
if (nums[u] >= last)
129+
{
130+
t.push_back(nums[u]);
131+
dfs(u + 1, nums[u], t, nums, ans);
132+
t.pop_back();
133+
}
134+
if (nums[u] != last) dfs(u + 1, last, t, nums, ans);
135+
}
136+
};
137+
```
57138

139+
### **Go**
140+
141+
```go
142+
func findSubsequences(nums []int) [][]int {
143+
var ans [][]int
144+
var dfs func(u, last int, t []int)
145+
dfs = func(u, last int, t []int) {
146+
if u == len(nums) {
147+
if len(t) > 1 {
148+
cp := make([]int, len(t))
149+
copy(cp, t)
150+
ans = append(ans, cp)
151+
}
152+
return
153+
}
154+
if nums[u] >= last {
155+
t = append(t, nums[u])
156+
dfs(u+1, nums[u], t)
157+
t = t[:len(t)-1]
158+
}
159+
if nums[u] != last {
160+
dfs(u+1, last, t)
161+
}
162+
}
163+
var t []int
164+
dfs(0, -1000, t)
165+
return ans
166+
}
58167
```
59168

60169
### **...**

‎solution/0400-0499/0491.Increasing Subsequences/README_EN.md

Lines changed: 103 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,13 +38,115 @@
3838
### **Python3**
3939

4040
```python
41-
41+
class Solution:
42+
def findSubsequences(self, nums: List[int]) -> List[List[int]]:
43+
def dfs(u, last, t):
44+
if u == len(nums):
45+
if len(t) > 1:
46+
ans.append(t[:])
47+
return
48+
if nums[u] >= last:
49+
t.append(nums[u])
50+
dfs(u + 1, nums[u], t)
51+
t.pop()
52+
if nums[u] != last:
53+
dfs(u + 1, last, t)
54+
55+
ans = []
56+
dfs(0, -1000, [])
57+
return ans
4258
```
4359

4460
### **Java**
4561

4662
```java
63+
class Solution {
64+
private int[] nums;
65+
private List<List<Integer>> ans;
66+
67+
public List<List<Integer>> findSubsequences(int[] nums) {
68+
this.nums = nums;
69+
ans = new ArrayList<>();
70+
dfs(0, -1000, new ArrayList<>());
71+
return ans;
72+
}
73+
74+
private void dfs(int u, int last, List<Integer> t) {
75+
if (u == nums.length) {
76+
if (t.size() > 1) {
77+
ans.add(new ArrayList<>(t));
78+
}
79+
return;
80+
}
81+
if (nums[u] >= last) {
82+
t.add(nums[u]);
83+
dfs(u + 1, nums[u], t);
84+
t.remove(t.size() - 1);
85+
}
86+
if (nums[u] != last) {
87+
dfs(u + 1, last, t);
88+
}
89+
}
90+
}
91+
```
92+
93+
### **C++**
94+
95+
```cpp
96+
class Solution {
97+
public:
98+
vector<vector<int>> findSubsequences(vector<int>& nums) {
99+
vector<vector<int>> ans;
100+
vector<int> t;
101+
dfs(0, -1000, t, nums, ans);
102+
return ans;
103+
}
104+
105+
void dfs(int u, int last, vector<int>& t, vector<int>& nums, vector<vector<int>>& ans) {
106+
if (u == nums.size())
107+
{
108+
if (t.size() > 1) ans.push_back(t);
109+
return;
110+
}
111+
if (nums[u] >= last)
112+
{
113+
t.push_back(nums[u]);
114+
dfs(u + 1, nums[u], t, nums, ans);
115+
t.pop_back();
116+
}
117+
if (nums[u] != last) dfs(u + 1, last, t, nums, ans);
118+
}
119+
};
120+
```
47121

122+
### **Go**
123+
124+
```go
125+
func findSubsequences(nums []int) [][]int {
126+
var ans [][]int
127+
var dfs func(u, last int, t []int)
128+
dfs = func(u, last int, t []int) {
129+
if u == len(nums) {
130+
if len(t) > 1 {
131+
cp := make([]int, len(t))
132+
copy(cp, t)
133+
ans = append(ans, cp)
134+
}
135+
return
136+
}
137+
if nums[u] >= last {
138+
t = append(t, nums[u])
139+
dfs(u+1, nums[u], t)
140+
t = t[:len(t)-1]
141+
}
142+
if nums[u] != last {
143+
dfs(u+1, last, t)
144+
}
145+
}
146+
var t []int
147+
dfs(0, -1000, t)
148+
return ans
149+
}
48150
```
49151

50152
### **...**

‎solution/0400-0499/0491.Increasing Subsequences/Solution.cpp

Lines changed: 24 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
vector<vector<int>> findSubsequences(vector<int>& nums) {
4+
vector<vector<int>> ans;
5+
vector<int> t;
6+
dfs(0, -1000, t, nums, ans);
7+
return ans;
8+
}
9+
10+
void dfs(int u, int last, vector<int>& t, vector<int>& nums, vector<vector<int>>& ans) {
11+
if (u == nums.size())
12+
{
13+
if (t.size() > 1) ans.push_back(t);
14+
return;
15+
}
16+
if (nums[u] >= last)
17+
{
18+
t.push_back(nums[u]);
19+
dfs(u + 1, nums[u], t, nums, ans);
20+
t.pop_back();
21+
}
22+
if (nums[u] != last) dfs(u + 1, last, t, nums, ans);
23+
}
24+
};

‎solution/0400-0499/0491.Increasing Subsequences/Solution.go

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
func findSubsequences(nums []int) [][]int {
2+
var ans [][]int
3+
var dfs func(u, last int, t []int)
4+
dfs = func(u, last int, t []int) {
5+
if u == len(nums) {
6+
if len(t) > 1 {
7+
cp := make([]int, len(t))
8+
copy(cp, t)
9+
ans = append(ans, cp)
10+
}
11+
return
12+
}
13+
if nums[u] >= last {
14+
t = append(t, nums[u])
15+
dfs(u+1, nums[u], t)
16+
t = t[:len(t)-1]
17+
}
18+
if nums[u] != last {
19+
dfs(u+1, last, t)
20+
}
21+
}
22+
var t []int
23+
dfs(0, -1000, t)
24+
return ans
25+
}

‎solution/0400-0499/0491.Increasing Subsequences/Solution.java

Lines changed: 28 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
class Solution {
2+
private int[] nums;
3+
private List<List<Integer>> ans;
4+
5+
public List<List<Integer>> findSubsequences(int[] nums) {
6+
this.nums = nums;
7+
ans = new ArrayList<>();
8+
dfs(0, -1000, new ArrayList<>());
9+
return ans;
10+
}
11+
12+
private void dfs(int u, int last, List<Integer> t) {
13+
if (u == nums.length) {
14+
if (t.size() > 1) {
15+
ans.add(new ArrayList<>(t));
16+
}
17+
return;
18+
}
19+
if (nums[u] >= last) {
20+
t.add(nums[u]);
21+
dfs(u + 1, nums[u], t);
22+
t.remove(t.size() - 1);
23+
}
24+
if (nums[u] != last) {
25+
dfs(u + 1, last, t);
26+
}
27+
}
28+
}

‎solution/0400-0499/0491.Increasing Subsequences/Solution.py

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution:
2+
def findSubsequences(self, nums: List[int]) -> List[List[int]]:
3+
def dfs(u, last, t):
4+
if u == len(nums):
5+
if len(t) > 1:
6+
ans.append(t[:])
7+
return
8+
if nums[u] >= last:
9+
t.append(nums[u])
10+
dfs(u + 1, nums[u], t)
11+
t.pop()
12+
if nums[u] != last:
13+
dfs(u + 1, last, t)
14+
15+
ans = []
16+
dfs(0, -1000, [])
17+
return ans

0 commit comments

Comments
 (0)