Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit db22205

Browse files
feat: add solutions to lc problem: No.0673.Number of Longest Increasing Subsequence
1 parent af98ff0 commit db22205

File tree

7 files changed

+395
-21
lines changed

7 files changed

+395
-21
lines changed

‎solution/0600-0699/0673.Number of Longest Increasing Subsequence/README.md‎

Lines changed: 141 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -31,22 +31,162 @@
3131

3232
<!-- 这里可写通用的实现逻辑 -->
3333

34+
[最长递增子序列](../../0300-0399/0300.Longest%20Increasing%20Subsequence/README.md)的变形题,除了原有的 `dp` 数组之外,另加了 `cnt` 数组记录以 `nums[i]` 结尾的最长子序列的个数
35+
3436
<!-- tabs:start -->
3537

3638
### **Python3**
3739

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

4042
```python
41-
43+
class Solution:
44+
def findNumberOfLIS(self, nums: List[int]) -> int:
45+
maxLen, ans, n = 0, 0, len(nums)
46+
dp, cnt = [1] * n, [1] * n
47+
for i in range(n):
48+
for j in range(i):
49+
if nums[i] > nums[j]:
50+
if dp[j] + 1 > dp[i]:
51+
dp[i] = dp[j] + 1
52+
cnt[i] = cnt[j]
53+
elif dp[j] + 1 == dp[i]:
54+
cnt[i] += cnt[j]
55+
if dp[i] > maxLen:
56+
maxLen = dp[i]
57+
ans = cnt[i]
58+
elif dp[i] == maxLen:
59+
ans += cnt[i]
60+
return ans
4261
```
4362

4463
### **Java**
4564

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

4867
```java
68+
class Solution {
69+
public int findNumberOfLIS(int[] nums) {
70+
int maxLen = 0, ans = 0, n = nums.length;
71+
int[] dp = new int[n];
72+
int[] cnt = new int[n];
73+
for (int i = 0; i < n; i++) {
74+
dp[i] = 1;
75+
cnt[i] = 1;
76+
for (int j = 0; j < i; j++) {
77+
if (nums[i] > nums[j]) {
78+
if (dp[j] + 1 > dp[i]) {
79+
dp[i] = dp[j] + 1;
80+
cnt[i] = cnt[j];
81+
} else if (dp[j] + 1 == dp[i]) {
82+
cnt[i] += cnt[j];
83+
}
84+
}
85+
}
86+
if (dp[i] > maxLen) {
87+
maxLen = dp[i];
88+
ans = cnt[i];
89+
} else if (dp[i] == maxLen) {
90+
ans += cnt[i];
91+
}
92+
}
93+
return ans;
94+
}
95+
}
96+
```
97+
98+
### **C++**
99+
100+
```cpp
101+
class Solution {
102+
public:
103+
int findNumberOfLIS(vector<int>& nums) {
104+
int maxLen = 0, ans = 0, n = nums.size();
105+
vector<int> dp(n, 1), cnt(n, 1);
106+
for (int i = 0; i < n; ++i) {
107+
for (int j = 0; j < i; ++j) {
108+
if (nums[i] > nums[j]) {
109+
if (dp[j] + 1 > dp[i]) {
110+
dp[i] = dp[j] + 1;
111+
cnt[i] = cnt[j];
112+
} else if (dp[j] + 1 == dp[i]) {
113+
cnt[i] += cnt[j];
114+
}
115+
}
116+
}
117+
if (dp[i] > maxLen) {
118+
maxLen = dp[i];
119+
ans = cnt[i];
120+
} else if (dp[i] == maxLen) {
121+
ans += cnt[i];
122+
}
123+
}
124+
return ans;
125+
}
126+
};
127+
```
128+
129+
### **Go**
130+
131+
```go
132+
func findNumberOfLIS(nums []int) int {
133+
maxLen, ans, n := 0, 0, len(nums)
134+
dp, cnt := make([]int, n), make([]int, n)
135+
for i := 0; i < n; i++ {
136+
dp[i] = 1
137+
cnt[i] = 1
138+
for j := 0; j < i; j++ {
139+
if nums[i] > nums[j] {
140+
if dp[j]+1 > dp[i] {
141+
dp[i] = dp[j] + 1
142+
cnt[i] = cnt[j]
143+
} else if dp[j]+1 == dp[i] {
144+
cnt[i] += cnt[j]
145+
}
146+
}
147+
}
148+
if dp[i] > maxLen {
149+
maxLen = dp[i]
150+
ans = cnt[i]
151+
} else if dp[i] == maxLen {
152+
ans += cnt[i]
153+
}
154+
}
155+
return ans
156+
}
157+
```
49158

159+
### **Rust**
160+
161+
```rust
162+
impl Solution {
163+
pub fn find_number_of_lis(nums: Vec<i32>) -> i32 {
164+
let mut max_len = 0;
165+
let mut ans = 0;
166+
let n = nums.len();
167+
let mut dp = vec![1; n];
168+
let mut cnt = vec![1; n];
169+
for i in 0..n {
170+
for j in 0..i {
171+
if nums[i] > nums[j] {
172+
if dp[j] + 1 > dp[i] {
173+
dp[i] = dp[j] + 1;
174+
cnt[i] = cnt[j];
175+
} else if dp[j] + 1 == dp[i] {
176+
cnt[i] += cnt[j];
177+
}
178+
}
179+
}
180+
if dp[i] > max_len {
181+
max_len = dp[i];
182+
ans = cnt[i];
183+
} else if dp[i] == max_len {
184+
ans += cnt[i];
185+
}
186+
}
187+
ans
188+
}
189+
}
50190
```
51191

52192
### **...**

‎solution/0600-0699/0673.Number of Longest Increasing Subsequence/README_EN.md‎

Lines changed: 143 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -37,18 +37,160 @@
3737

3838
## Solutions
3939

40+
similar problem: [LIS](../../0300-0399/0300.Longest%20Increasing%20Subsequence/README_EN.md)
41+
42+
`cnt` array records the number of longest sequence ending in `nums[i]`
43+
4044
<!-- tabs:start -->
4145

4246
### **Python3**
4347

4448
```python
45-
49+
class Solution:
50+
def findNumberOfLIS(self, nums: List[int]) -> int:
51+
maxLen, ans, n = 0, 0, len(nums)
52+
dp, cnt = [1] * n, [1] * n
53+
for i in range(n):
54+
for j in range(i):
55+
if nums[i] > nums[j]:
56+
if dp[j] + 1 > dp[i]:
57+
dp[i] = dp[j] + 1
58+
cnt[i] = cnt[j]
59+
elif dp[j] + 1 == dp[i]:
60+
cnt[i] += cnt[j]
61+
if dp[i] > maxLen:
62+
maxLen = dp[i]
63+
ans = cnt[i]
64+
elif dp[i] == maxLen:
65+
ans += cnt[i]
66+
return ans
4667
```
4768

4869
### **Java**
4970

5071
```java
72+
class Solution {
73+
public int findNumberOfLIS(int[] nums) {
74+
int maxLen = 0, ans = 0, n = nums.length;
75+
int[] dp = new int[n];
76+
int[] cnt = new int[n];
77+
for (int i = 0; i < n; i++) {
78+
dp[i] = 1;
79+
cnt[i] = 1;
80+
for (int j = 0; j < i; j++) {
81+
if (nums[i] > nums[j]) {
82+
if (dp[j] + 1 > dp[i]) {
83+
dp[i] = dp[j] + 1;
84+
cnt[i] = cnt[j];
85+
} else if (dp[j] + 1 == dp[i]) {
86+
cnt[i] += cnt[j];
87+
}
88+
}
89+
}
90+
if (dp[i] > maxLen) {
91+
maxLen = dp[i];
92+
ans = cnt[i];
93+
} else if (dp[i] == maxLen) {
94+
ans += cnt[i];
95+
}
96+
}
97+
return ans;
98+
}
99+
}
100+
```
101+
102+
### **C++**
103+
104+
```cpp
105+
class Solution {
106+
public:
107+
int findNumberOfLIS(vector<int>& nums) {
108+
int maxLen = 0, ans = 0, n = nums.size();
109+
vector<int> dp(n, 1), cnt(n, 1);
110+
for (int i = 0; i < n; ++i) {
111+
for (int j = 0; j < i; ++j) {
112+
if (nums[i] > nums[j]) {
113+
if (dp[j] + 1 > dp[i]) {
114+
dp[i] = dp[j] + 1;
115+
cnt[i] = cnt[j];
116+
} else if (dp[j] + 1 == dp[i]) {
117+
cnt[i] += cnt[j];
118+
}
119+
}
120+
}
121+
if (dp[i] > maxLen) {
122+
maxLen = dp[i];
123+
ans = cnt[i];
124+
} else if (dp[i] == maxLen) {
125+
ans += cnt[i];
126+
}
127+
}
128+
return ans;
129+
}
130+
};
131+
```
132+
133+
### **Go**
134+
135+
```go
136+
func findNumberOfLIS(nums []int) int {
137+
maxLen, ans, n := 0, 0, len(nums)
138+
dp, cnt := make([]int, n), make([]int, n)
139+
for i := 0; i < n; i++ {
140+
dp[i] = 1
141+
cnt[i] = 1
142+
for j := 0; j < i; j++ {
143+
if nums[i] > nums[j] {
144+
if dp[j]+1 > dp[i] {
145+
dp[i] = dp[j] + 1
146+
cnt[i] = cnt[j]
147+
} else if dp[j]+1 == dp[i] {
148+
cnt[i] += cnt[j]
149+
}
150+
}
151+
}
152+
if dp[i] > maxLen {
153+
maxLen = dp[i]
154+
ans = cnt[i]
155+
} else if dp[i] == maxLen {
156+
ans += cnt[i]
157+
}
158+
}
159+
return ans
160+
}
161+
```
51162

163+
### **Rust**
164+
165+
```rust
166+
impl Solution {
167+
pub fn find_number_of_lis(nums: Vec<i32>) -> i32 {
168+
let mut max_len = 0;
169+
let mut ans = 0;
170+
let n = nums.len();
171+
let mut dp = vec![1; n];
172+
let mut cnt = vec![1; n];
173+
for i in 0..n {
174+
for j in 0..i {
175+
if nums[i] > nums[j] {
176+
if dp[j] + 1 > dp[i] {
177+
dp[i] = dp[j] + 1;
178+
cnt[i] = cnt[j];
179+
} else if dp[j] + 1 == dp[i] {
180+
cnt[i] += cnt[j];
181+
}
182+
}
183+
}
184+
if dp[i] > max_len {
185+
max_len = dp[i];
186+
ans = cnt[i];
187+
} else if dp[i] == max_len {
188+
ans += cnt[i];
189+
}
190+
}
191+
ans
192+
}
193+
}
52194
```
53195

54196
### **...**
Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public:
3+
int findNumberOfLIS(vector<int>& nums) {
4+
int maxLen = 0, ans = 0, n = nums.size();
5+
vector<int> dp(n, 1), cnt(n, 1);
6+
for (int i = 0; i < n; ++i) {
7+
for (int j = 0; j < i; ++j) {
8+
if (nums[i] > nums[j]) {
9+
if (dp[j] + 1 > dp[i]) {
10+
dp[i] = dp[j] + 1;
11+
cnt[i] = cnt[j];
12+
} else if (dp[j] + 1 == dp[i]) {
13+
cnt[i] += cnt[j];
14+
}
15+
}
16+
}
17+
if (dp[i] > maxLen) {
18+
maxLen = dp[i];
19+
ans = cnt[i];
20+
} else if (dp[i] == maxLen) {
21+
ans += cnt[i];
22+
}
23+
}
24+
return ans;
25+
}
26+
};
Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,25 @@
1+
func findNumberOfLIS(nums []int) int {
2+
maxLen, ans, n := 0, 0, len(nums)
3+
dp, cnt := make([]int, n), make([]int, n)
4+
for i := 0; i < n; i++ {
5+
dp[i] = 1
6+
cnt[i] = 1
7+
for j := 0; j < i; j++ {
8+
if nums[i] > nums[j] {
9+
if dp[j]+1 > dp[i] {
10+
dp[i] = dp[j] + 1
11+
cnt[i] = cnt[j]
12+
} else if dp[j]+1 == dp[i] {
13+
cnt[i] += cnt[j]
14+
}
15+
}
16+
}
17+
if dp[i] > maxLen {
18+
maxLen = dp[i]
19+
ans = cnt[i]
20+
} else if dp[i] == maxLen {
21+
ans += cnt[i]
22+
}
23+
}
24+
return ans
25+
}

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /