Skip to content

feat: add solutions to lc problem: No.0873 #3255

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Jul 11, 2024
Merged

feat: add solutions to lc problem: No.0873 #3255

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
205 changes: 135 additions & 70 deletions solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -69,8 +69,15 @@ tags:

### 方法一：动态规划

- 状态表示：`dp[j][i]` 表示斐波那契式最后两项为 `arr[j]`, `arr[i]` 时的最大子序列长度。
- 状态计算：`dp[j][i] = dp[k][j] + 1`（当且仅当 `k < j < i`，并且 `arr[k] + arr[j] == arr[i]`）, `ans = max(ans, dp[j][i])`。
我们定义 $f[i][j]$ 表示以 $\textit{arr}[i]$ 作为最后一个元素，以 $\textit{arr}[j]$ 作为倒数第二个元素的最长斐波那契子序列的长度。初始时，对于任意的 $i \in [0, n)$ 和 $j \in [0, i)$，都有 $f[i][j] = 2$。其余的元素都是 $0$。

我们用一个哈希表 $d$ 记录数组 $\textit{arr}$ 中每个元素对应的下标。

然后，我们可以枚举 $\textit{arr}[i]$ 和 $\textit{arr}[j]$，其中 $i \in [2, n)$ 且 $j \in [1, i)$。假设当前枚举到的元素是 $\textit{arr}[i]$ 和 $\textit{arr}[j]$，我们可以得到 $\textit{arr}[i] - \textit{arr}[j]$，记作 $t$。如果 $t$ 在数组 $\textit{arr}$ 中，且 $t$ 的下标 $k$ 满足 $k < j$，那么我们可以得到一个以 $\textit{arr}[j]$ 和 $\textit{arr}[i]$ 作为最后两个元素的斐波那契子序列，其长度为 $f[i][j] = \max(f[i][j], f[j][k] + 1)$。我们可以用这种方法不断更新 $f[i][j]$ 的值，然后更新答案。

枚举结束后，返回答案即可。

时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 是数组 $\textit{arr}$ 的长度。

<!-- tabs:start -->

Expand All @@ -79,19 +86,19 @@ tags:
```python
class Solution:
def lenLongestFibSubseq(self, arr: List[int]) -> int:
mp = {v: i for i, v in enumerate(arr)}
n = len(arr)
dp = [[0] * n for _ in range(n)]
f = [[0] * n for _ in range(n)]
d = {x: i for i, x in enumerate(arr)}
for i in range(n):
for j in range(i):
dp[j][i] = 2
f[i][j] = 2
ans = 0
for i in range(n):
for j in range(i):
d = arr[i] - arr[j]
if d in mp and (k := mp[d]) < j:
dp[j][i] = max(dp[j][i], dp[k][j] + 1)
ans = max(ans, dp[j][i])
for i in range(2, n):
for j in range(1, i):
t = arr[i] - arr[j]
if t in d and (k := d[t]) < j:
f[i][j] = max(f[i][j], f[j][k] + 1)
ans = max(ans, f[i][j])
return ans
```

Expand All @@ -101,26 +108,22 @@ class Solution:
class Solution {
public int lenLongestFibSubseq(int[] arr) {
int n = arr.length;
Map<Integer, Integer> mp = new HashMap<>();
for (int i = 0; i < n; ++i) {
mp.put(arr[i], i);
}
int[][] dp = new int[n][n];
int[][] f = new int[n][n];
Map<Integer, Integer> d = new HashMap<>();
for (int i = 0; i < n; ++i) {
d.put(arr[i], i);
for (int j = 0; j < i; ++j) {
dp[j][i] = 2;
f[i][j] = 2;
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < i; ++j) {
int d = arr[i] - arr[j];
if (mp.containsKey(d)) {
int k = mp.get(d);
if (k < j) {
dp[j][i] = Math.max(dp[j][i], dp[k][j] + 1);
ans = Math.max(ans, dp[j][i]);
}
for (int i = 2; i < n; ++i) {
for (int j = 1; j < i; ++j) {
int t = arr[i] - arr[j];
Integer k = d.get(t);
if (k != null && k < j) {
f[i][j] = Math.max(f[i][j], f[j][k] + 1);
ans = Math.max(ans, f[i][j]);
}
}
}
Expand All @@ -135,23 +138,26 @@ class Solution {
class Solution {
public:
int lenLongestFibSubseq(vector<int>& arr) {
unordered_map<int, int> mp;
int n = arr.size();
for (int i = 0; i < n; ++i) mp[arr[i]] = i;
vector<vector<int>> dp(n, vector<int>(n));
for (int i = 0; i < n; ++i)
for (int j = 0; j < i; ++j)
dp[j][i] = 2;
int ans = 0;
int f[n][n];
memset(f, 0, sizeof(f));
unordered_map<int, int> d;
for (int i = 0; i < n; ++i) {
d[arr[i]] = i;
for (int j = 0; j < i; ++j) {
int d = arr[i] - arr[j];
if (mp.count(d)) {
int k = mp[d];
if (k < j) {
dp[j][i] = max(dp[j][i], dp[k][j] + 1);
ans = max(ans, dp[j][i]);
}
f[i][j] = 2;
}
}

int ans = 0;
for (int i = 2; i < n; ++i) {
for (int j = 1; j < i; ++j) {
int t = arr[i] - arr[j];
auto it = d.find(t);
if (it != d.end() && it->second < j) {
int k = it->second;
f[i][j] = max(f[i][j], f[j][k] + 1);
ans = max(ans, f[i][j]);
}
}
}
Expand All @@ -163,31 +169,92 @@ public:
#### Go

```go
func lenLongestFibSubseq(arr []int) int {
func lenLongestFibSubseq(arr []int) (ans int) {
n := len(arr)
mp := make(map[int]int, n)
for i, v := range arr {
mp[v] = i + 1
f := make([][]int, n)
for i := range f {
f[i] = make([]int, n)
}
dp := make([][]int, n)
for i := 0; i < n; i++ {
dp[i] = make([]int, n)

d := make(map[int]int)
for i, x := range arr {
d[x] = i
for j := 0; j < i; j++ {
dp[j][i] = 2
f[i][j] = 2
}
}
ans := 0
for i := 0; i < n; i++ {
for j := 0; j < i; j++ {
d := arr[i] - arr[j]
k := mp[d] - 1
if k >= 0 && k < j {
dp[j][i] = max(dp[j][i], dp[k][j]+1)
ans = max(ans, dp[j][i])

for i := 2; i < n; i++ {
for j := 1; j < i; j++ {
t := arr[i] - arr[j]
if k, ok := d[t]; ok && k < j {
f[i][j] = max(f[i][j], f[j][k]+1)
ans = max(ans, f[i][j])
}
}
}
return ans

return
}
```

#### TypeScript

```ts
function lenLongestFibSubseq(arr: number[]): number {
const n = arr.length;
const f: number[][] = Array.from({ length: n }, () => Array(n).fill(0));
const d: Map<number, number> = new Map();
for (let i = 0; i < n; ++i) {
d.set(arr[i], i);
for (let j = 0; j < i; ++j) {
f[i][j] = 2;
}
}
let ans = 0;
for (let i = 2; i < n; ++i) {
for (let j = 1; j < i; ++j) {
const t = arr[i] - arr[j];
const k = d.get(t);
if (k !== undefined && k < j) {
f[i][j] = Math.max(f[i][j], f[j][k] + 1);
ans = Math.max(ans, f[i][j]);
}
}
}
return ans;
}
```

#### Rust

```rust
use std::collections::HashMap;
impl Solution {
pub fn len_longest_fib_subseq(arr: Vec<i32>) -> i32 {
let n = arr.len();
let mut f = vec![vec![0; n]; n];
let mut d = HashMap::new();
for i in 0..n {
d.insert(arr[i], i);
for j in 0..i {
f[i][j] = 2;
}
}
let mut ans = 0;
for i in 2..n {
for j in 1..i {
let t = arr[i] - arr[j];
if let Some(&k) = d.get(&t) {
if k < j {
f[i][j] = f[i][j].max(f[j][k] + 1);
ans = ans.max(f[i][j]);
}
}
}
}
ans
}
}
```

Expand All @@ -199,25 +266,23 @@ func lenLongestFibSubseq(arr []int) int {
* @return {number}
*/
var lenLongestFibSubseq = function (arr) {
const mp = new Map();
const n = arr.length;
const dp = new Array(n).fill(0).map(() => new Array(n).fill(0));
const f = Array.from({ length: n }, () => Array(n).fill(0));
const d = new Map();
for (let i = 0; i < n; ++i) {
mp.set(arr[i], i);
d.set(arr[i], i);
for (let j = 0; j < i; ++j) {
dp[j][i] = 2;
f[i][j] = 2;
}
}
let ans = 0;
for (let i = 0; i < n; ++i) {
for (let j = 0; j < i; ++j) {
const d = arr[i] - arr[j];
if (mp.has(d)) {
const k = mp.get(d);
if (k < j) {
dp[j][i] = Math.max(dp[j][i], dp[k][j] + 1);
ans = Math.max(ans, dp[j][i]);
}
for (let i = 2; i < n; ++i) {
for (let j = 1; j < i; ++j) {
const t = arr[i] - arr[j];
const k = d.get(t);
if (k !== undefined && k < j) {
f[i][j] = Math.max(f[i][j], f[j][k] + 1);
ans = Math.max(ans, f[i][j]);
}
}
}
Expand Down
Loading
Loading