Skip to content

Commit db22205

Browse files
maolonglongmaolonglong
committedSep 21, 2021
feat: add solutions to lc problem: No.0673.Number of Longest Increasing Subsequence
·
v0.1.9v0.1.7
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

+141-1
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

+143-1
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
### **...**

‎solution/0600-0699/0673.Number of Longest Increasing Subsequence/Solution.cpp

+26
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+
};

‎solution/0600-0699/0673.Number of Longest Increasing Subsequence/Solution.go

+25
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+
}

‎solution/0600-0699/0673.Number of Longest Increasing Subsequence/Solution.java

+14-19
Original file line numberDiff line numberDiff line change
@@ -1,33 +1,28 @@
11
class Solution {
22
public int findNumberOfLIS(int[] nums) {
3-
if (nums == null || nums.length == 0) {
4-
return 0;
5-
}
6-
int n = nums.length;
3+
int maxLen = 0, ans = 0, n = nums.length;
74
int[] dp = new int[n];
8-
int[] f = new int[n];
9-
Arrays.fill(dp, 1);
10-
Arrays.fill(f, 1);
11-
int max = 0;
12-
for (int i = 0; i < n; ++i) {
13-
for (int j = 0; j < i; ++j) {
5+
int[] cnt = new int[n];
6+
for (int i = 0; i < n; i++) {
7+
dp[i] = 1;
8+
cnt[i] = 1;
9+
for (int j = 0; j < i; j++) {
1410
if (nums[i] > nums[j]) {
1511
if (dp[j] + 1 > dp[i]) {
1612
dp[i] = dp[j] + 1;
17-
f[i] = f[j];
13+
cnt[i] = cnt[j];
1814
} else if (dp[j] + 1 == dp[i]) {
19-
f[i] += f[j];
15+
cnt[i] += cnt[j];
2016
}
2117
}
2218
}
23-
max = Math.max(max, dp[i]);
24-
}
25-
int res = 0;
26-
for (int i = 0; i < n; ++i) {
27-
if (dp[i] == max) {
28-
res += f[i];
19+
if (dp[i] > maxLen) {
20+
maxLen = dp[i];
21+
ans = cnt[i];
22+
} else if (dp[i] == maxLen) {
23+
ans += cnt[i];
2924
}
3025
}
31-
return res;
26+
return ans;
3227
}
3328
}

‎solution/0600-0699/0673.Number of Longest Increasing Subsequence/Solution.py

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
class Solution:
2+
def findNumberOfLIS(self, nums: List[int]) -> int:
3+
maxLen, ans, n = 0, 0, len(nums)
4+
dp, cnt = [1] * n, [1] * n
5+
for i in range(n):
6+
for j in range(i):
7+
if nums[i] > nums[j]:
8+
if dp[j] + 1 > dp[i]:
9+
dp[i] = dp[j] + 1
10+
cnt[i] = cnt[j]
11+
elif dp[j] + 1 == dp[i]:
12+
cnt[i] += cnt[j]
13+
if dp[i] > maxLen:
14+
maxLen = dp[i]
15+
ans = cnt[i]
16+
elif dp[i] == maxLen:
17+
ans += cnt[i]
18+
return ans

‎solution/0600-0699/0673.Number of Longest Increasing Subsequence/Solution.rs

+28
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,28 @@
1+
impl Solution {
2+
pub fn find_number_of_lis(nums: Vec<i32>) -> i32 {
3+
let mut max_len = 0;
4+
let mut ans = 0;
5+
let n = nums.len();
6+
let mut dp = vec![1; n];
7+
let mut cnt = vec![1; n];
8+
for i in 0..n {
9+
for j in 0..i {
10+
if nums[i] > nums[j] {
11+
if dp[j] + 1 > dp[i] {
12+
dp[i] = dp[j] + 1;
13+
cnt[i] = cnt[j];
14+
} else if dp[j] + 1 == dp[i] {
15+
cnt[i] += cnt[j];
16+
}
17+
}
18+
}
19+
if dp[i] > max_len {
20+
max_len = dp[i];
21+
ans = cnt[i];
22+
} else if dp[i] == max_len {
23+
ans += cnt[i];
24+
}
25+
}
26+
ans
27+
}
28+
}

0 commit comments

Comments
 (0)
Please sign in to comment.