feat: update solutions to lc problem: No.0873

yanglbme · web-flow · commit 6182124b7b39 · 2022-07-09T02:17:12.000Z
No.0873.Length of Longest Fibonacci Subsequence
diff --git a/solution/0000-0099/0007.Reverse Integer/README.md b/solution/0000-0099/0007.Reverse Integer/README.md
@@ -164,21 +164,21 @@ func reverse(x int) int {
 	slot := make([]int, 11)
 	count := 0
 	for x != 0 {
-		n := x%10
+		n := x % 10
 		slot[count] = n
 		count++
 		x /= 10
 	}
 	result := 0
 	flag := true
-    for i := 0; i < count; i++ {
+	for i := 0; i < count; i++ {
 		if flag && slot[i] == 0 {
 			continue
 		}
 		flag = false
-		result = 10 * result + slot[i]
+		result = 10*result + slot[i]
 	}
-    if result > math.MaxInt32 || result < math.MinInt32 {
+	if result > math.MaxInt32 || result < math.MinInt32 {
 		return 0
 	}
 	return result
@@ -187,7 +187,7 @@ func reverse(x int) int {
 
 ### **C#**
 
-```rb
+```cs
 public class Solution {
     public int Reverse(int x) {
         var negative = x < 0;
diff --git a/solution/0000-0099/0007.Reverse Integer/README_EN.md b/solution/0000-0099/0007.Reverse Integer/README_EN.md
@@ -143,21 +143,21 @@ func reverse(x int) int {
 	slot := make([]int, 11)
 	count := 0
 	for x != 0 {
-		n := x%10
+		n := x % 10
 		slot[count] = n
 		count++
 		x /= 10
 	}
 	result := 0
 	flag := true
-    for i := 0; i < count; i++ {
+	for i := 0; i < count; i++ {
 		if flag && slot[i] == 0 {
 			continue
 		}
 		flag = false
-		result = 10 * result + slot[i]
+		result = 10*result + slot[i]
 	}
-    if result > math.MaxInt32 || result < math.MinInt32 {
+	if result > math.MaxInt32 || result < math.MinInt32 {
 		return 0
 	}
 	return result
@@ -166,7 +166,7 @@ func reverse(x int) int {
 
 ### **C#**
 
-```rb
+```cs
 public class Solution {
     public int Reverse(int x) {
         var negative = x < 0;
diff --git a/solution/0000-0099/0007.Reverse Integer/Solution.go b/solution/0000-0099/0007.Reverse Integer/Solution.go
@@ -2,21 +2,21 @@ func reverse(x int) int {
 	slot := make([]int, 11)
 	count := 0
 	for x != 0 {
-		n := x%10
+		n := x % 10
 		slot[count] = n
 		count++
 		x /= 10
 	}
 	result := 0
 	flag := true
-    for i := 0; i < count; i++ {
+	for i := 0; i < count; i++ {
 		if flag && slot[i] == 0 {
 			continue
 		}
 		flag = false
-		result = 10 * result + slot[i]
+		result = 10*result + slot[i]
 	}
-    if result > math.MaxInt32 || result < math.MinInt32 {
+	if result > math.MaxInt32 || result < math.MinInt32 {
 		return 0
 	}
 	return result
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
@@ -53,7 +53,7 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-动态规划。
+**方法一：动态规划**
 
 -   状态表示：`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])`。
@@ -76,12 +76,10 @@ class Solution:
         ans = 0
         for i in range(n):
             for j in range(i):
-                delta = arr[i] - arr[j]
-                if delta in mp:
-                    k = mp[delta]
-                    if k < j:
-                        dp[j][i] = dp[k][j] + 1
-                        ans = max(ans, dp[j][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])
         return ans
 ```
 
@@ -106,11 +104,11 @@ class Solution {
         int ans = 0;
         for (int i = 0; i < n; ++i) {
             for (int j = 0; j < i; ++j) {
-                int delta = arr[i] - arr[j];
-                if (mp.containsKey(delta)) {
-                    int k = mp.get(delta);
+                int d = arr[i] - arr[j];
+                if (mp.containsKey(d)) {
+                    int k = mp.get(d);
                     if (k < j) {
-                        dp[j][i] = dp[k][j] + 1;
+                        dp[j][i] = Math.max(dp[j][i], dp[k][j] + 1);
                         ans = Math.max(ans, dp[j][i]);
                     }
                 }
@@ -132,22 +130,20 @@ public:
         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;
         for (int i = 0; i < n; ++i)
         {
             for (int j = 0; j < i; ++j)
             {
-                int delta = arr[i] - arr[j];
-                if (mp.count(delta))
+                int d = arr[i] - arr[j];
+                if (mp.count(d))
                 {
-                    int k = mp[delta];
+                    int k = mp[d];
                     if (k < j)
                     {
-                        dp[j][i] = dp[k][j] + 1;
+                        dp[j][i] = max(dp[j][i], dp[k][j] + 1);
                         ans = max(ans, dp[j][i]);
                     }
                 }
@@ -177,10 +173,10 @@ func lenLongestFibSubseq(arr []int) int {
 	ans := 0
 	for i := 0; i < n; i++ {
 		for j := 0; j < i; j++ {
-			delta := arr[i] - arr[j]
-			k := mp[delta] - 1
+			d := arr[i] - arr[j]
+			k := mp[d] - 1
 			if k >= 0 && k < j {
-				dp[j][i] = dp[k][j] + 1
+				dp[j][i] = max(dp[j][i], dp[k][j]+1)
 				ans = max(ans, dp[j][i])
 			}
 		}
@@ -196,6 +192,40 @@ func max(a, b int) int {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {number[]} arr
+ * @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));
+    for (let i = 0; i < n; ++i) {
+        mp.set(arr[i], i);
+        for (let j = 0; j < i; ++j) {
+            dp[j][i] = 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]);
+                }
+            }
+        }
+    }
+    return ans;
+};
+```
+
 ### **...**
 
 ```
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
@@ -58,12 +58,10 @@ class Solution:
         ans = 0
         for i in range(n):
             for j in range(i):
-                delta = arr[i] - arr[j]
-                if delta in mp:
-                    k = mp[delta]
-                    if k < j:
-                        dp[j][i] = dp[k][j] + 1
-                        ans = max(ans, dp[j][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])
         return ans
 ```
 
@@ -86,11 +84,11 @@ class Solution {
         int ans = 0;
         for (int i = 0; i < n; ++i) {
             for (int j = 0; j < i; ++j) {
-                int delta = arr[i] - arr[j];
-                if (mp.containsKey(delta)) {
-                    int k = mp.get(delta);
+                int d = arr[i] - arr[j];
+                if (mp.containsKey(d)) {
+                    int k = mp.get(d);
                     if (k < j) {
-                        dp[j][i] = dp[k][j] + 1;
+                        dp[j][i] = Math.max(dp[j][i], dp[k][j] + 1);
                         ans = Math.max(ans, dp[j][i]);
                     }
                 }
@@ -112,22 +110,20 @@ public:
         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;
         for (int i = 0; i < n; ++i)
         {
             for (int j = 0; j < i; ++j)
             {
-                int delta = arr[i] - arr[j];
-                if (mp.count(delta))
+                int d = arr[i] - arr[j];
+                if (mp.count(d))
                 {
-                    int k = mp[delta];
+                    int k = mp[d];
                     if (k < j)
                     {
-                        dp[j][i] = dp[k][j] + 1;
+                        dp[j][i] = max(dp[j][i], dp[k][j] + 1);
                         ans = max(ans, dp[j][i]);
                     }
                 }
@@ -157,10 +153,10 @@ func lenLongestFibSubseq(arr []int) int {
 	ans := 0
 	for i := 0; i < n; i++ {
 		for j := 0; j < i; j++ {
-			delta := arr[i] - arr[j]
-			k := mp[delta] - 1
+			d := arr[i] - arr[j]
+			k := mp[d] - 1
 			if k >= 0 && k < j {
-				dp[j][i] = dp[k][j] + 1
+				dp[j][i] = max(dp[j][i], dp[k][j]+1)
 				ans = max(ans, dp[j][i])
 			}
 		}
@@ -176,6 +172,40 @@ func max(a, b int) int {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {number[]} arr
+ * @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));
+    for (let i = 0; i < n; ++i) {
+        mp.set(arr[i], i);
+        for (let j = 0; j < i; ++j) {
+            dp[j][i] = 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]);
+                }
+            }
+        }
+    }
+    return ans;
+};
+```
+
 ### **...**
 
 ```
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
@@ -6,22 +6,20 @@ class Solution {
         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;
         for (int i = 0; i < n; ++i)
         {
             for (int j = 0; j < i; ++j)
             {
-                int delta = arr[i] - arr[j];
-                if (mp.count(delta))
+                int d = arr[i] - arr[j];
+                if (mp.count(d))
                 {
-                    int k = mp[delta];
+                    int k = mp[d];
                     if (k < j)
                     {
-                        dp[j][i] = dp[k][j] + 1;
+                        dp[j][i] = max(dp[j][i], dp[k][j] + 1);
                         ans = max(ans, dp[j][i]);
                     }
                 }
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
@@ -14,10 +14,10 @@ func lenLongestFibSubseq(arr []int) int {
 	ans := 0
 	for i := 0; i < n; i++ {
 		for j := 0; j < i; j++ {
-			delta := arr[i] - arr[j]
-			k := mp[delta] - 1
+			d := arr[i] - arr[j]
+			k := mp[d] - 1
 			if k >= 0 && k < j {
-				dp[j][i] = dp[k][j] + 1
+				dp[j][i] = max(dp[j][i], dp[k][j]+1)
 				ans = max(ans, dp[j][i])
 			}
 		}
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
@@ -14,11 +14,11 @@ public int lenLongestFibSubseq(int[] arr) {
         int ans = 0;
         for (int i = 0; i < n; ++i) {
             for (int j = 0; j < i; ++j) {
-                int delta = arr[i] - arr[j];
-                if (mp.containsKey(delta)) {
-                    int k = mp.get(delta);
+                int d = arr[i] - arr[j];
+                if (mp.containsKey(d)) {
+                    int k = mp.get(d);
                     if (k < j) {
-                        dp[j][i] = dp[k][j] + 1;
+                        dp[j][i] = Math.max(dp[j][i], dp[k][j] + 1);
                         ans = Math.max(ans, dp[j][i]);
                     }
                 }
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
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

Original file line number	Diff line number	Diff line change
`@@ -6,22 +6,20 @@ class Solution {`
`6`	`6`	`for (int i = 0; i < n; ++i) mp[arr[i]] = i;`
`7`	`7`	`vector<vector<int>> dp(n, vector<int>(n));`
`8`	`8`	`for (int i = 0; i < n; ++i)`
`9`		`- {`
`10`	`9`	`for (int j = 0; j < i; ++j)`
`11`	`10`	`dp[j][i] = 2;`
`12`		`- }`
`13`	`11`	`int ans = 0;`
`14`	`12`	`for (int i = 0; i < n; ++i)`
`15`	`13`	`{`
`16`	`14`	`for (int j = 0; j < i; ++j)`
`17`	`15`	`{`
`18`		`- int delta = arr[i] - arr[j];`
`19`		`- if (mp.count(delta))`
	`16`	`+ int d = arr[i] - arr[j];`
	`17`	`+ if (mp.count(d))`
`20`	`18`	`{`
`21`		`- int k = mp[delta];`
	`19`	`+ int k = mp[d];`
`22`	`20`	`if (k < j)`
`23`	`21`	`{`
`24`		`- dp[j][i] = dp[k][j] + 1;`
	`22`	`+ dp[j][i] = max(dp[j][i], dp[k][j] + 1);`
`25`	`23`	`ans = max(ans, dp[j][i]);`
`26`	`24`	`}`
`27`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,10 +14,10 @@ func lenLongestFibSubseq(arr []int) int {`
`14`	`14`	`ans := 0`
`15`	`15`	`for i := 0; i < n; i++ {`
`16`	`16`	`for j := 0; j < i; j++ {`
`17`		`- delta := arr[i] - arr[j]`
`18`		`- k := mp[delta] - 1`
	`17`	`+ d := arr[i] - arr[j]`
	`18`	`+ k := mp[d] - 1`
`19`	`19`	`if k >= 0 && k < j {`
`20`		`- dp[j][i] = dp[k][j] + 1`
	`20`	`+ dp[j][i] = max(dp[j][i], dp[k][j]+1)`
`21`	`21`	`ans = max(ans, dp[j][i])`
`22`	`22`	`}`
`23`	`23`	`}`