剑指 Offer II 093. 最长斐波那契数列

1. 背

这道题不难理解，但是细节容易有问题。
dp[i][j]表示以arr[i]结尾的时候，前一个数字是arr[j]时的斐波那契额数列。
现在有三个数字，a,b,c，假设它们时斐波那契数列，那么一定满足a+b=c，a的下标时index_a，b的下标是index_b,c的下标是index_c，那么dp[index_a][index_b] = dp[index_b][index_c]+1。
当遍历到i的时候，再在0~i-1中找一个j，这个j，这个i就是上面的index_c，j就是上面的index_b，此时能够计算出一个target和其对应的index（只能用哈希反过来找）。
上面只是简单的dp关系，有些特殊情况要好好处理。例如

1. target这个数字是否存在。这个很好理解，不存在根本就不能称作斐波那契数列。可能想，如果不存在，这个值肯定是0啊，但是还有更好的办法，有个target，那么一定会有target_index，如果没有，那就是这个target不存在。
2. abc三个数字的关系。比如i当前的值是12，遍历到的j是1，那么target就是11，不过11、1、12这三个数根本就不是斐波那契数列，要排除。
3. 还有就是数组的初始值。dp的初值正常来说应该给1，因为一个数字就是长度为1的斐波那契数列，但是判断的时候是三个三个一起判断，target,arr[j]和arr[i]三个数字组合到一起才能是一个斐波那契数列。因为每次都是比前一个多1，因此我就把结果都给2了。

2. 题目

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

n >= 3
对于所有 i + 2 <= n，都有 X_i + X_{i+1} = X_{i+2}
给定一个严格递增的正整数数组形成序列 arr ，找到 arr 中最长的斐波那契式的子序列的长度。如果一个不存在，返回 0 。

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

示例 1：

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

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/Q91FMA
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

3. 答案

class Solution {
public:
    int lenLongestFibSubseq(vector<int>& arr) {
        int row = arr.size();
        int col = row;
        unordered_map<int,int>dp_map;
        for(int i=0;i<row;++i)
            dp_map[arr[i]] = i;

        vector<vector<int>>dp(row,vector<int>(col,2));

        auto ret =INT_MIN;
        for(int i=2;i<row;++i)
        {
            for(int j=0;j<i;++j)
            {
                auto target = arr[i] - arr[j];
                //三个数字分别是arr[i],arr[j],target
                if(arr[i]>arr[j]&&arr[j]>target&&dp_map.find(arr[j])!=dp_map.end() && dp_map.find(target)!=dp_map.end())//<arr[i]>arr[j]不需要判断，因为是必然的，dp_map.find(arr[j])!=dp_map.end()其实也不需要判断，也是必然的，所以真正需要判断的就是第二个和第四个，都写上思路比较清晰
                {
                    auto index_j = dp_map[arr[j]];//<这个index_j其实可以不用，因为j和index肯定相等
                    auto index_target = dp_map[target];
                    dp[i][index_j] = dp[index_j][index_target]+1;//<dp方程其实就这一行
                    ret = max(ret, dp[i][index_j]);
                }
                    
            }
        }
        return ret<3?0:ret;
    }
};