From 57242130401cc156aae10ec2b57296db6b69951a Mon Sep 17 00:00:00 2001 From: yanglbme Date: Thu, 11 Jul 2024 13:08:20 +0800 Subject: [PATCH] feat: add solutions to lc problem: No.0873 No.0873.Length of Longest Fibonacci Subsequence --- .../README.md | 205 +++++++++++------ .../README_EN.md | 206 ++++++++++++------ .../Solution.cpp | 31 +-- .../Solution.go | 35 +-- .../Solution.java | 26 +-- .../Solution.js | 24 +- .../Solution.py | 18 +- .../Solution.rs | 27 +++ .../Solution.ts | 23 ++ 9 files changed, 388 insertions(+), 207 deletions(-) create mode 100644 solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.rs create mode 100644 solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.ts diff --git a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README.md b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README.md index 759ea21feabf1..ed6e907943729 100644 --- a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README.md +++ b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README.md @@ -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}$ 的长度。 @@ -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 ``` @@ -101,26 +108,22 @@ class Solution: class Solution { public int lenLongestFibSubseq(int[] arr) { int n = arr.length; - Map 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 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]); } } } @@ -135,23 +138,26 @@ class Solution { class Solution { public: int lenLongestFibSubseq(vector& arr) { - unordered_map mp; int n = arr.size(); - for (int i = 0; i < n; ++i) mp[arr[i]] = i; - vector> dp(n, vector(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 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]); } } } @@ -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 = 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 { + 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 + } } ``` @@ -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]); } } } diff --git a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README_EN.md b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README_EN.md index eb5974a2fa75f..fc69e4d4c0b9c 100644 --- a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README_EN.md +++ b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/README_EN.md @@ -58,7 +58,17 @@ tags: -### Solution 1 +### Solution 1: Dynamic Programming + +We define $f[i][j]$ as the length of the longest Fibonacci-like subsequence, with $\textit{arr}[i]$ as the last element and $\textit{arr}[j]$ as the second to last element. Initially, for any $i \in [0, n)$ and $j \in [0, i)$, we have $f[i][j] = 2$. All other elements are $0$. + +We use a hash table $d$ to record the indices of each element in the array $\textit{arr}$. + +Then, we can enumerate $\textit{arr}[i]$ and $\textit{arr}[j]$, where $i \in [2, n)$ and $j \in [1, i)$. Suppose the currently enumerated elements are $\textit{arr}[i]$ and $\textit{arr}[j]$, we can obtain $\textit{arr}[i] - \textit{arr}[j]$, denoted as $t$. If $t$ is in the array $\textit{arr}$, and the index $k$ of $t$ satisfies $k < j$, then we can get a Fibonacci-like subsequence with $\textit{arr}[j]$ and $\textit{arr}[i]$ as the last two elements, and its length is $f[i][j] = \max(f[i][j], f[j][k] + 1)$. We can continuously update the value of $f[i][j]$ in this way, and then update the answer. + +After the enumeration ends, return the answer. + +The time complexity is $O(n^2)$, and the space complexity is $O(n^2)$, where $n$ is the length of the array $\textit{arr}$. @@ -67,19 +77,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 ``` @@ -89,26 +99,22 @@ class Solution: class Solution { public int lenLongestFibSubseq(int[] arr) { int n = arr.length; - Map 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 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]); } } } @@ -123,23 +129,26 @@ class Solution { class Solution { public: int lenLongestFibSubseq(vector& arr) { - unordered_map mp; int n = arr.size(); - for (int i = 0; i < n; ++i) mp[arr[i]] = i; - vector> dp(n, vector(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 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]); } } } @@ -151,31 +160,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 = 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 { + 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 + } } ``` @@ -187,25 +257,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]); } } } diff --git a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.cpp b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.cpp index 116435eda8f19..10a65f50566ba 100644 --- a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.cpp +++ b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.cpp @@ -1,23 +1,26 @@ class Solution { public: int lenLongestFibSubseq(vector& arr) { - unordered_map mp; int n = arr.size(); - for (int i = 0; i < n; ++i) mp[arr[i]] = i; - vector> dp(n, vector(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 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]); } } } diff --git a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.go b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.go index 22c438d1b5aa7..a37697c072702 100644 --- a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.go +++ b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.go @@ -1,26 +1,27 @@ -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 } \ No newline at end of file diff --git a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.java b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.java index 5a813ce54f22a..e11eba810cf8c 100644 --- a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.java +++ b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.java @@ -1,26 +1,22 @@ class Solution { public int lenLongestFibSubseq(int[] arr) { int n = arr.length; - Map 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 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]); } } } diff --git a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.js b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.js index 9c01c35d08a38..a69418600ad13 100644 --- a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.js +++ b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.js @@ -3,25 +3,23 @@ * @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]); } } } diff --git a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.py b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.py index 1d231ba338c4f..f343a054490c0 100644 --- a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.py +++ b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.py @@ -1,16 +1,16 @@ 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 diff --git a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.rs b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.rs new file mode 100644 index 0000000000000..12569d4a9b283 --- /dev/null +++ b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.rs @@ -0,0 +1,27 @@ +use std::collections::HashMap; +impl Solution { + pub fn len_longest_fib_subseq(arr: Vec) -> 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 + } +} diff --git a/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.ts b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.ts new file mode 100644 index 0000000000000..cf7cbe56cf5e6 --- /dev/null +++ b/solution/0800-0899/0873.Length of Longest Fibonacci Subsequence/Solution.ts @@ -0,0 +1,23 @@ +function lenLongestFibSubseq(arr: number[]): number { + const n = arr.length; + const f: number[][] = Array.from({ length: n }, () => Array(n).fill(0)); + const d: Map = 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; +}