Skip to content

Commit 9df3b47

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.1027
No.1027.Longest Arithmetic Subsequence
1 parent 631d780 commit 9df3b47

File tree

6 files changed

+215
-15
lines changed

6 files changed

+215
-15
lines changed

‎solution/1000-1099/1027.Longest Arithmetic Subsequence/README.md

+78-1
Original file line numberDiff line numberDiff line change
@@ -52,22 +52,99 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
**方法一：动态规划**
56+
5557
<!-- tabs:start -->
5658

5759
### **Python3**
5860

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

6163
```python
62-
64+
class Solution:
65+
def longestArithSeqLength(self, nums: List[int]) -> int:
66+
n = len(nums)
67+
dp = [[1] * 1001 for _ in range(n)]
68+
ans = 0
69+
for i in range(1, n):
70+
for j in range(i):
71+
d = nums[i] - nums[j] + 500
72+
dp[i][d] = max(dp[i][d], dp[j][d] + 1)
73+
ans = max(ans, dp[i][d])
74+
return ans
6375
```
6476

6577
### **Java**
6678

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

6981
```java
82+
class Solution {
83+
public int longestArithSeqLength(int[] nums) {
84+
int n = nums.length;
85+
int ans = 0;
86+
int[][] dp = new int[n][1001];
87+
for (int i = 1; i < n; ++i) {
88+
for (int j = 0; j < i; ++j) {
89+
int d = nums[i] - nums[j] + 500;
90+
dp[i][d] = Math.max(dp[i][d], dp[j][d] + 1);
91+
ans = Math.max(ans, dp[i][d]);
92+
}
93+
}
94+
return ans + 1;
95+
}
96+
}
97+
```
98+
99+
### **C++**
100+
101+
```cpp
102+
class Solution {
103+
public:
104+
int longestArithSeqLength(vector<int>& nums) {
105+
int n = nums.size();
106+
int ans = 0;
107+
vector<vector<int>> dp(n, vector<int>(1001, 1));
108+
for (int i = 1; i < n; ++i)
109+
{
110+
for (int j = 0; j < i; ++j)
111+
{
112+
int d = nums[i] - nums[j] + 500;
113+
dp[i][d] = max(dp[i][d], dp[j][d] + 1);
114+
ans = max(ans, dp[i][d]);
115+
}
116+
}
117+
return ans;
118+
}
119+
};
120+
```
70121
122+
### **Go**
123+
124+
```go
125+
func longestArithSeqLength(nums []int) int {
126+
n := len(nums)
127+
dp := make([][]int, n)
128+
for i := range dp {
129+
dp[i] = make([]int, 1001)
130+
}
131+
ans := 0
132+
for i := 1; i < n; i++ {
133+
for j := 0; j < i; j++ {
134+
d := nums[i] - nums[j] + 500
135+
dp[i][d] = max(dp[i][d], dp[j][d]+1)
136+
ans = max(ans, dp[i][d])
137+
}
138+
}
139+
return ans + 1
140+
}
141+
142+
func max(a, b int) int {
143+
if a > b {
144+
return a
145+
}
146+
return b
147+
}
71148
```
72149

73150
### **...**

‎solution/1000-1099/1027.Longest Arithmetic Subsequence/README_EN.md

+76-1
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,88 @@ The longest arithmetic subsequence is [20,15,10,5].
5151
### **Python3**
5252

5353
```python
54-
54+
class Solution:
55+
def longestArithSeqLength(self, nums: List[int]) -> int:
56+
n = len(nums)
57+
dp = [[1] * 1001 for _ in range(n)]
58+
ans = 0
59+
for i in range(1, n):
60+
for j in range(i):
61+
d = nums[i] - nums[j] + 500
62+
dp[i][d] = max(dp[i][d], dp[j][d] + 1)
63+
ans = max(ans, dp[i][d])
64+
return ans
5565
```
5666

5767
### **Java**
5868

5969
```java
70+
class Solution {
71+
public int longestArithSeqLength(int[] nums) {
72+
int n = nums.length;
73+
int ans = 0;
74+
int[][] dp = new int[n][1001];
75+
for (int i = 1; i < n; ++i) {
76+
for (int j = 0; j < i; ++j) {
77+
int d = nums[i] - nums[j] + 500;
78+
dp[i][d] = Math.max(dp[i][d], dp[j][d] + 1);
79+
ans = Math.max(ans, dp[i][d]);
80+
}
81+
}
82+
return ans + 1;
83+
}
84+
}
85+
```
86+
87+
### **C++**
88+
89+
```cpp
90+
class Solution {
91+
public:
92+
int longestArithSeqLength(vector<int>& nums) {
93+
int n = nums.size();
94+
int ans = 0;
95+
vector<vector<int>> dp(n, vector<int>(1001, 1));
96+
for (int i = 1; i < n; ++i)
97+
{
98+
for (int j = 0; j < i; ++j)
99+
{
100+
int d = nums[i] - nums[j] + 500;
101+
dp[i][d] = max(dp[i][d], dp[j][d] + 1);
102+
ans = max(ans, dp[i][d]);
103+
}
104+
}
105+
return ans;
106+
}
107+
};
108+
```
60109
110+
### **Go**
111+
112+
```go
113+
func longestArithSeqLength(nums []int) int {
114+
n := len(nums)
115+
dp := make([][]int, n)
116+
for i := range dp {
117+
dp[i] = make([]int, 1001)
118+
}
119+
ans := 0
120+
for i := 1; i < n; i++ {
121+
for j := 0; j < i; j++ {
122+
d := nums[i] - nums[j] + 500
123+
dp[i][d] = max(dp[i][d], dp[j][d]+1)
124+
ans = max(ans, dp[i][d])
125+
}
126+
}
127+
return ans + 1
128+
}
129+
130+
func max(a, b int) int {
131+
if a > b {
132+
return a
133+
}
134+
return b
135+
}
61136
```
62137

63138
### **...**

‎solution/1000-1099/1027.Longest Arithmetic Subsequence/Solution.cpp

+12-13
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,18 @@
11
class Solution {
2-
unordered_map<int, int> tested; // map (start index * 1005 + steps) to longest length
32
public:
4-
int longestArithSeqLength(vector<int>& A) {
5-
int res = 0;
6-
for (int i = 0; i < A.size(); ++i) {
7-
for (int j = 0; j < i; ++j) {
8-
int diff = A[i] - A[j];
9-
if (tested.count(j*10005 + diff)) {
10-
tested[i*10005+diff] = max(tested[i*10005+diff], 1+tested[j*10005 + diff]);
11-
} else {
12-
tested[i*10005+diff] = max(tested[i*10005+diff], 2);
13-
}
14-
res = max(res, tested[i*10005+diff]);
3+
int longestArithSeqLength(vector<int>& nums) {
4+
int n = nums.size();
5+
int ans = 0;
6+
vector<vector<int>> dp(n, vector<int>(1001, 1));
7+
for (int i = 1; i < n; ++i)
8+
{
9+
for (int j = 0; j < i; ++j)
10+
{
11+
int d = nums[i] - nums[j] + 500;
12+
dp[i][d] = max(dp[i][d], dp[j][d] + 1);
13+
ans = max(ans, dp[i][d]);
1514
}
1615
}
17-
return res;
16+
return ans;
1817
}
1918
};

‎solution/1000-1099/1027.Longest Arithmetic Subsequence/Solution.go

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
func longestArithSeqLength(nums []int) int {
2+
n := len(nums)
3+
dp := make([][]int, n)
4+
for i := range dp {
5+
dp[i] = make([]int, 1001)
6+
}
7+
ans := 0
8+
for i := 1; i < n; i++ {
9+
for j := 0; j < i; j++ {
10+
d := nums[i] - nums[j] + 500
11+
dp[i][d] = max(dp[i][d], dp[j][d]+1)
12+
ans = max(ans, dp[i][d])
13+
}
14+
}
15+
return ans + 1
16+
}
17+
18+
func max(a, b int) int {
19+
if a > b {
20+
return a
21+
}
22+
return b
23+
}

‎solution/1000-1099/1027.Longest Arithmetic Subsequence/Solution.java

+15
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
class Solution {
2+
public int longestArithSeqLength(int[] nums) {
3+
int n = nums.length;
4+
int ans = 0;
5+
int[][] dp = new int[n][1001];
6+
for (int i = 1; i < n; ++i) {
7+
for (int j = 0; j < i; ++j) {
8+
int d = nums[i] - nums[j] + 500;
9+
dp[i][d] = Math.max(dp[i][d], dp[j][d] + 1);
10+
ans = Math.max(ans, dp[i][d]);
11+
}
12+
}
13+
return ans + 1;
14+
}
15+
}

‎solution/1000-1099/1027.Longest Arithmetic Subsequence/Solution.py

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
class Solution:
2+
def longestArithSeqLength(self, nums: List[int]) -> int:
3+
n = len(nums)
4+
dp = [[1] * 1001 for _ in range(n)]
5+
ans = 0
6+
for i in range(1, n):
7+
for j in range(i):
8+
d = nums[i] - nums[j] + 500
9+
dp[i][d] = max(dp[i][d], dp[j][d] + 1)
10+
ans = max(ans, dp[i][d])
11+
return ans

0 commit comments

Comments
 (0)