数组类问题思路，以leetcode873寻找最长斐波那契子序列和1027寻找最长等差数组为例

一般，数组问题中
如果寻找满足某些要求的连续的子数组，可以优先考虑用双指针 或者滑动窗口的方法解决。双指针从广义上来说，是指用两个变量在线性结构上遍历而解决的问题。狭义上说，
对于数组，指两个变量在数组上相向移动解决的问题；
对于链表，指两个变量在链表上同向移动解决的问题，也称为「快慢指针」问题。
双指针算法通常不难，双指针算法是基于暴力解法的优化，

而对于寻找满足某些要求的不连续子数组，最好考虑动态规划，一维，二维动态规划都经常用到。重要的是找到迭代公式以及限制条件，比如leetcode873寻找最长斐波那契子序列和1027寻找最长等差数组，都是不仅仅要知道当前的信息，不能像leetcode300寻找最大上升子序列中那样之定义dp[i]的意义，最大上升子序列的子序列中，每一个子数组元素可以说除了一个比一个大，没人任何其他关系。但是这两题里面，一个需要满足斐波那契公式，另一个需要满足等差数组关系，所有这里还需要知道目标数组
下面介绍两种适合用于h i j 模式下的动态规划
比如

leetcode873 就需要满足nums[i]+nums[j]=nums[k]
leetcode1027需要满足nums[k]-nums[j]=nums[j]-nums[i]
所以我们可以考虑定义两种数据结构来统计子序列长度
一种是
dp为字典 的dp={ (i,j):count }表示以i和j为结尾的子序列的长度
另一种写成dp=[[2 for _ in range(n)] for _ in range(n)]
注意一下这里的dp是深拷贝，而dp=[[2]*n]*n是浅拷贝，用前者比较好
同时用一个idx字典将nums[i]作为key，i作为value记录，这样在后续查询会方便很多，也省去了时间。

下面给出两题目的多种解法
第一题是leetcode873 最长斐波那契子序列
输入: arr = [1,2,3,4,5,6,7,8]
输出: 5
解释: 最长的斐波那契式子序列为 [1,2,3,5,8]

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

解法一 dp为字典
class Solution:
    def lenLongestFibSubseq(self, arr: List[int]) -> int:
        n = len(arr)
        idx={}
        dp={}
        res=0
        for i in range(n):
            for j in range(i+1,n):
                arr_h=arr[j]-arr[i]
                if arr_h in idx:
                    dp[(i,j)]=dp.get((idx[arr_h],i),2 )+1
                res = max(res, dp.get((i,j),2))
            idx[arr[i]]=i
        return res if res >=3 else 0
解法二 dp为2d数组
class Solution:
    def lenLongestFibSubseq(self, arr: List[int]) -> int:
        n=len(arr)
        idx={}
        res=1
        dp=[[2 for _ in range(n)] for _ in range(n)]
        for i in range(n):
            for j in range(i+1,n):
                arr_h=arr[j]-arr[i]
                if arr_h in idx:
                    dp[i][j]=dp[idx[arr_h]][i]+1
                    print(i,j)
                res=max(res,dp[i][j])
            idx[arr[i]]=i
        return res if res>=3 else 0

第二题leetcode 1027 最长等差数列

解法1和解法2都在下面的代码里面了，具体见注释。
由于这里的diff都是一样的，所以也可以把dp[i][j]变成dp[i][diff]
不过为了和leetcode873保持思想一致，我没有那么写
class Solution:
    def longestArithSeqLength(self, nums: List[int]) -> int:
        n = len(nums)
        # dp = [[2 for _ in range(n)] for _ in range(n)]
        dp={}
        idx = {}
        res = 0
        for i in range(n):
            for j in range(i + 1, n):
                pre = nums[i] * 2 - nums[j]
                if pre in idx:
                    # dp[i][j] = dp[idx[pre]][i] + 1 
                    dp[(i,j)]=dp.get((idx[pre],i),2)+1
                    #以nums[i]和nums[j]为结尾的等差数组
                res = max(res, dp.get((i,j),2))
            idx[nums[i]] = i
        return res