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

No.0873.Length of Longest Fibonacci Subsequence

Author: yanglbme

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}$ 的长度。
 
 <!-- tabs:start -->
 
@@ -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<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]);
                 }
             }
         }
@@ -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]);
                 }
             }
         }
@@ -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
+    }
 }
 ```
 
@@ -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]);
             }
         }
     }