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

Posted 2021-08-27 数据结构和算法

截止到目前我已经写了 500多道算法题，其中部分已经整理成了pdf文档，目前总共有1000多页（并且还会不断的增加），大家可以免费下载
下载链接：https://pan.baidu.com/s/1hjwK0ZeRxYGB8lIkbKuQgQ
提取码：6666

public int lenLongestFibSubseq(int[] A) {
    int size = A.length;
    //先把数组A中的所有元素都存储在Set中
    Set<Integer> set = new HashSet<>();
    for (int num : A)
        set.add(num);
    //记录构成的最长斐波那契数列的长度
    int maxLength = 0;
    for (int i = 0; i < size; ++i)
        for (int j = i + 1; j < size; ++j) {
            //斐波那契数列的第一项
            int first = A[i];
            //斐波那契数列的第二项
            int second = A[j];
            //当前斐波那契数列的长度
            int len = 2;
            //斐波那契数列前两项和等于第三项的值，这里
            //判断数组A中是否存在前两项的和
            while (set.contains(first + second)) {
                //如果能构成斐波那契数列，我们需要更新后面的值，
                //(first, second) -> (second, first+second)
                second = first + second;
                first = second - first;
                //记录当前能构成的斐波那契数列的长度
                len++;
            }
            //更新最大的斐波那契数列长度
            if (len > maxLength)
                maxLength = len;
        }
    //能构成斐波那契数列，长度必须大于等于3，如果小于3，
    //说明不能构成斐波那契数列，直接返回0，否则返回maxLength
    return maxLength >= 3 ? maxLength : 0;
}

    for (int j = 2; j < length; j++) {//确定A[j]
        for (int i = j - 1; i > 0; i--) {//确定A[i]
            for (int k = i - 1; k >= 0; k--) {//往前查找A[k]
                if (A[k] + A[i] == A[j]) {
                    dp[i][j] = dp[k][i] + 1;
                    //如果找到就终止内层循环，不在往前查找了
                    break;
                } else if (A[k] + A[i] < A[j]) {
                    //题中说了是递增的正整数数组，如果当前A[k]
                    //小了，那么前面的就更小，没有合适的，没必要
                    //在往前找了，直接终止内层循环
                    break;
                }
            }
            maxLength = Math.max(maxLength, dp[i][j]);
        }
    }

我们来看下最终代码

public int lenLongestFibSubseq(int[] A) {
    //记录最大的斐波那契数列的长度
    int maxLength = 0;
    int length = A.length;
    int[][] dp = new int[length][length];
    for (int j = 2; j < length; j++) {//确定A[j]
        for (int i = j - 1; i > 0; i--) {//确定A[i]
            for (int k = i - 1; k >= 0; k--) {//往前查找A[k]
                if (A[k] + A[i] == A[j]) {
                    dp[i][j] = dp[k][i] + 1;
                    //如果找到就终止内层循环，不在往前查找了
                    break;
                } else if (A[k] + A[i] < A[j]) {
                    //题中说了是递增的正整数数组，如果当前A[k]
                    //小了，那么前面的就更小，没有合适的，没必要
                    //在往前找了，直接终止内层循环
                    break;
                }
            }
            maxLength = Math.max(maxLength, dp[i][j]);
        }
    }
    //注意数列长度统计的时候没有统计前面两项，如果能构成
    //斐波那契数列最后还需要加上
    return maxLength > 0 ? maxLength + 2 : 0;
}

public int lenLongestFibSubseq(int[] A) {
    //记录最大的斐波那契数列的长度
    int maxLength = 0;
    int length = A.length;
    int[][] dp = new int[length][length];
    Map<Integer, Integer> map = new HashMap<>();
    for (int j = 0; j < length; j++) {//确定A[j]
        map.put(A[j], j);
        for (int i = j - 1; i > 0; i--) {//确定A[i]
            //因为是递增的，如果A[j]和A[i]之间相差比较大，
            //就不需要再往前查找了
            if (A[j] - A[i] >= A[i])
                continue;
            //通过map往前查找A[k]
            int k = map.getOrDefault(A[j] - A[i], -1);
            //如果k不等于-1，说明在数组中找到了A[k]这个值
            if (k >= 0) {
                dp[i][j] = dp[k][i] + 1;
                maxLength = Math.max(maxLength, dp[i][j]);
            }
        }
    }
    return maxLength > 0 ? maxLength + 2 : 0;
}

视频链接

最后再来看下代码

public int lenLongestFibSubseq(int[] A) {
    //记录最大的斐波那契数列的长度
    int maxLength = 0;
    int length = A.length;
    int[][] dp = new int[length][length];
    for (int j = 2; j < length; j++) {//确定A[j]
        //左右两个指针
        int left = 0;
        int right = j - 1;
        while (left < right) {
            //两个指针指向值的和
            int sum = A[left] + A[right];
            if (sum > A[j]) {
                //因为数组是递增的，如果两个指针指向的值
                //大了，那么右指针往左移一步来减小他俩的和
                right--;
            } else if (sum < A[j]) {
                //如果两个指针指向的值小了，那么左指针往
                //右移一步来增大他俩的和
                left++;
            } else {
                //如果两个指针指向的和等于A[j]，说明这两个指针
                //指向的值和A[j]可以构成斐波那契数列
                dp[right][j] = dp[left][right] + 1;
                maxLength = Math.max(maxLength, dp[right][j]);
                right--;
                left++;
            }
        }
    }
    return maxLength > 0 ? maxLength + 2 : 0;
}