LeetCode 873 最长的斐波那契序列的长度[双指针 二分法 动态规划 Map] HERODING的LeetCode之路

解题思路：
首先想到的思路是双指针的方法，先用一前一后指针固定符合斐波那契规律的前两个位置，然后查找二者之和是否存在，存在则更新两个指针，继续往下找，结束更新当前最长序列长度，代码如下：

class Solution {
public:
    int lenLongestFibSubseq(vector<int>& arr) {
        int maxLen = 0;
        int n = arr.size();
        for(int i = 0; i < n - 1; i ++) {
            for(int j = i + 1; j < n; j ++) {
                int first = arr[i];
                int second = arr[j];
                // 定义当前长度
                int cur = 2;
                while(find(arr.begin(), arr.end(), first + second) != arr.end()) {
                    int count = first + second;
                    first = second;
                    second = count;
                    cur ++;
                }
                maxLen = max(maxLen, cur);
            }
        }
        return maxLen >= 3 ? maxLen : 0;
    }
};

但是很可惜，上述方法超时了，这是因为时间复杂度来到了O(n³)，所以需要进行优化，因为序列严格递增，所以查找时候用二分法，可以将时间复杂度优化至O(n²logn)，代码如下：

class Solution {
public:
    int lenLongestFibSubseq(vector<int>& arr) {
        int maxLen = 0;
        int n = arr.size();
        for(int i = 0; i < n - 1; i ++) {
            for(int j = i + 1; j < n; j ++) {
                int first = arr[i];
                int second = arr[j];
                // 定义当前长度
                int cur = 2;
                while(1) {
                    int index = lower_bound(arr.begin(), arr.end(), first + second) - arr.begin();
                    int count = first + second;
                    if(index >= n || arr[index] != count) {
                        break;
                    }
                    first = second;
                    second = count;
                    cur ++;
                }
                maxLen = max(maxLen, cur);
            }
        }
        return maxLen >= 3 ? maxLen : 0;
    }
};

时间复杂度仍然很高，但是已经可以ac了，接下来用空间换时间的方法进一步优化时间复杂度，用map记录下每个数值是否存在，这用双指针查找的时候就更加便利，代码如下：

class Solution {
public:
    int lenLongestFibSubseq(vector<int>& arr) {
        unordered_map<int, int> mp;
        int maxLen = 0;
        int n = arr.size();
        for(int i = 0; i < n; i ++) {
            mp[arr[i]] = i;
        }
        for(int i = 0; i < n - 1; i ++) {
            for(int j = i + 1; j < n; j ++) {
                int first = arr[i];
                int second = arr[j];
                // 定义当前长度
                int cur = 2;
                while(mp.count(first + second)) {
                    int count = first + second;
                    first = second;
                    second = count;
                    cur ++;
                }
                maxLen = max(maxLen, cur);
            }
        }
        return maxLen >= 3 ? maxLen : 0;
    }
};

动态规划的方法显然更加便捷，思路本质上也是双指针，先定义好dp数组dp[j][i]，表示最后两个数位置为j和i时所在的最长序列长度，仍然用map记录下每个数值的位置，然后双指针遍历数组并不断更新dp[j][i]，最后返回最长序列长度，代码如下：

class Solution {
public:
    int lenLongestFibSubseq(vector<int>& arr) {
        unordered_map<int, int> mp;
        int maxLen = 0;
        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 = i - 1; j >= 0 && arr[j] * 2 > arr[i]; j --) {
                if(mp.count(arr[i] - arr[j])) {
                    int index = mp[arr[i] - arr[j]];
                    dp[j][i] = max(dp[index][j] + 1, 3);
                }
                maxLen = max(maxLen, dp[j][i]);
            }
        }
        return maxLen >= 3 ? maxLen : 0;
    }
};