leetcode1027

最直接的思路是三层循环，但是会超时，代码如下：

public class Solution
    {
        public int LongestArithSeqLength2(int[] A)
        {
            var maxLength = 2;
            var len = A.Count();
            for (var i = 0; i < len; i++)
            {
                for (var j = i + 1; j < len; j++)
                {
                    var curmax = 2;
                    var target = A[i] - A[j];
                    var next = A[j] - target;
                    for (var k = j + 1; k < len; k++)
                    {
                        if (A[k] == next)
                        {
                            curmax++;
                            next = A[k] - target;
                        }

                    }
                    maxLength = Math.Max(maxLength, curmax);
                }
            }
            return maxLength;
        }
    }

但同样的代码，使用java实现，却可以正常提交，leetcode对这道题目的的判断机制有点奇怪。

如果想解决超时问题，可以考虑使用哈希或者dp思想，来减少判断的时间。

这种题目，做起来很麻烦，看看别人的思路吧。

当时没想出来怎么做，经过一段时间的练习(两个半月)，重新做这道题目，顺利做出来了，说明练习还是有效果的。

给出一份python的实现：

class Solution:
    def longestArithSeqLength(self, A: 'List[int]') -> int:
        n = len(A)
        if n == 2:
            return 2
        dic = {0:{0:1}}
        longest = 0
        for i in range(1,n):
            if i not in dic:
                dic[i] = {0:1}
            for j in range(i):
                diff = A[i] - A[j]
                if diff not in dic[j]:
                    dic[i][diff] = 2
                else:
                    dic[i][diff] = dic[j][diff] + 1
                longest = max(longest,dic[i][diff])
        return longest

使用hash缓存之前的记录，从三层循环减少为两层循环，时间复杂度为O(n^2)，但是增加了空间复杂度。典型的用空间换时间的思想。

dic是一个字典，key值是数组的下标，value值是一个字典类型。

这个value字典，key值是int类型，表示两项之间的差；value值是int类型，表示这个差值形成的等差数列的长度。

因此每次循环用longest记录任意一个差值所形成的最长的等差数列的长度，即为所求。