[Swift]LeetCode873. 最长的斐波那契子序列的长度 | Length of Longest Fibonacci Subsequence

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10600243.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

A sequence X_1, X_2, ..., X_n is fibonacci-like if:

• n >= 3
• X_i + X_{i+1} = X_{i+2} for all i + 2 <= n

Given a strictly increasing array A of positive integers forming a sequence, find the length of the longest fibonacci-like subsequence of A.  If one does not exist, return 0.

(Recall that a subsequence is derived from another sequence A by deleting any number of elements (including none) from A, without changing the order of the remaining elements.  For example, [3, 5, 8] is a subsequence of [3, 4, 5, 6, 7, 8].) 

Example 1:

Input: [1,2,3,4,5,6,7,8]
Output: 5
Explanation:
The longest subsequence that is fibonacci-like: [1,2,3,5,8].

Example 2:

Input: [1,3,7,11,12,14,18]
Output: 3
Explanation:
The longest subsequence that is fibonacci-like:
[1,11,12], [3,11,14] or [7,11,18]. 

Note:

• 3 <= A.length <= 1000
• 1 <= A[0] < A[1] < ... < A[A.length - 1] <= 10^9
• (The time limit has been reduced by 50% for submissions in Java, C, and C++.)

---

如果序列 X_1, X_2, ..., X_n 满足下列条件，就说它是 斐波那契式 的：

• n >= 3
• 对于所有 i + 2 <= n，都有 X_i + X_{i+1} = X_{i+2}

给定一个严格递增的正整数数组形成序列，找到 A 中最长的斐波那契式的子序列的长度。如果一个不存在，返回  0 。

（回想一下，子序列是从原序列 A 中派生出来的，它从 A 中删掉任意数量的元素（也可以不删），而不改变其余元素的顺序。例如， [3, 5, 8] 是 [3, 4, 5, 6, 7, 8] 的一个子序列） 

示例 1：

输入: [1,2,3,4,5,6,7,8]
输出: 5
解释:
最长的斐波那契式子序列为：[1,2,3,5,8] 。

示例 2：

输入: [1,3,7,11,12,14,18]
输出: 3
解释:
最长的斐波那契式子序列有：
[1,11,12]，[3,11,14] 以及 [7,11,18] 。 

提示：

• 3 <= A.length <= 1000
• 1 <= A[0] < A[1] < ... < A[A.length - 1] <= 10^9
• （对于以 Java，C，C++，以及 C# 的提交，时间限制被减少了 50%）

---

228ms

class Solution {
    func lenLongestFibSubseq(_ A: [Int]) -> Int {

        var dic = [Int:Int]()
        for item in 0..<A.count{
            dic[A[item]] = item
        }

        var dp = [[Int]](repeating:[Int](repeating: 0, count: A.count) , count: A.count)
        var result = 0
        for i in 0..<A.count {
            for j in 0..<i{
                if A[i] - A[j] < A[j] && dic[A[i] - A[j]] != nil {
                    dp[j][i] = dp[dic[A[i] - A[j]]!][j] + 1
                    result = max(result, dp[j][i])
                }
            }
        }
        return result > 0 ? result + 2 : 0
    }
}

---

236ms

class Solution {
    func lenLongestFibSubseq(_ A: [Int]) -> Int {
        var map = [Int: Int]()
        for (index, a) in A.enumerated() {
            map[a] = index
        }
        
        var result = 0
        var dp = [[Int]](repeating: [Int](repeating: 2, count: A.count), count: A.count)
        for i in 0 ..< A.count {
            for j in i+1 ..< A.count {
                let a = A[i], b = A[j], c = b - a
                if map[c] != nil {
                    if map[c]! >= i {
                        break
                    }
                    dp[i][j] = dp[map[c]!][i] + 1
                    result = max(result, dp[i][j])
                }
            }
        }
        
        return result
    }
}

---

368ms

class Solution {
    func lenLongestFibSubseq(_ A: [Int]) -> Int {
        let N = A.count
        var indexMap = [Int: Int]()
        for i in 0..<N {
            indexMap[A[i]] = i
        }
        
        var longestMap = [Int: Int]()
        var ans = 0
        
        for k in 0..<N {
            for j in 0..<k {
                guard let i = indexMap[A[k] - A[j]] else {
                    continue
                }
                if i < j {
                    var temp = 0
                    if let cand = longestMap[i * N + j] {
                        temp = cand + 1
                    } else {
                        temp = 3
                    }
                    longestMap[j * N + k] = temp
                    ans = max(ans, temp)
                }
            }
        }
        
        return ans >= 3 ? ans : 0
    }
}

---

376ms

class Solution {
    func lenLongestFibSubseq(_ A: [Int]) -> Int {
        var n = A.count, res = 0
        var dp = [[Int]](repeating: [Int](repeating: 2, count: n), count: n)
        var m = [Int: Int]()
        for i in 0..<n {
            m[A[i]] = i
        }
        for j in 1..<n {
            for i in 0..<j {
                if let idx = m[A[j] - A[i]], idx < i {
                    dp[i][j] = max(dp[i][j], dp[idx][i] + 1)
                    res = max(res, dp[i][j])
                } 
            }
        }
        return res
    }
}

---

388ms

class Solution {
    func lenLongestFibSubseq(_ A: [Int]) -> Int {
        let set = Set(A)
        var res = 0
        for i in 0 ..< A.count {
            for j in i + 1 ..< A.count {
                var a = A[i]
                var b = A[j]
                var c = a + b
                var size = 2
                while set.contains(c) {
                    size += 1
                    res = max(res, size)
                    a = b
                    b = c
                    c = a + b
                }   
            }
        }
        return res
    }
}

---

392ms

class Solution {
    func lenLongestFibSubseq(_ A: [Int]) -> Int {
        let N = A.count
        if N <= 2 { return N }
        
        var map = [Int: Int]()
        for i in 0..<N { map[A[i]] = i }

        var res = 0
        var dp = Array(repeating: Array(repeating: 2, count: N), count: N)
        for i in (0..<N - 1).reversed() {
            for j in (i + 1..<N) {
                if let k = map[A[i] + A[j]] {
                    dp[i][j] = dp[j][k] + 1
                    res = max(res, dp[i][j])
                }
            }
        }
        return res
    }
}