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

Posted HERODING23

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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(n3),所以需要进行优化,因为序列严格递增,所以查找时候用二分法,可以将时间复杂度优化至O(n2logn),代码如下:

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;
    
;

以上是关于LeetCode 873 最长的斐波那契序列的长度[双指针 二分法 动态规划 Map] HERODING的LeetCode之路的主要内容,如果未能解决你的问题,请参考以下文章

LeetCode 0873.最长的斐波那契子序列的长度

每日一题873. 最长的斐波那契子序列的长度

873. 最长的斐波那契子序列的长度

最长斐波那契序列-LeetCode-873

Leetcode 873 最长斐波那契子序列 记忆化递归与剪枝DP

python python中的斐波那契序列