leetcode1027

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

 public class Solution
     {
         public int LongestArithSeqLength2(int[] A)
         {
             var maxLength = ;
             var len = A.Count();
             for (var i = ; i < len; i++)
             {
                 for (var j = i + ; j < len; j++)
                 {
                     var curmax = ;
                     var target = A[i] - A[j];
                     var next = A[j] - target;
                     for (var k = j + ; 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 == :
             return
         dic = {:{:}}
         longest =
         for i in range(,n):
             if i not in dic:
                 dic[i] = {:}
             for j in range(i):
                 diff = A[i] - A[j]
                 if diff not in dic[j]:
                     dic[i][diff] =
                 else:
                     dic[i][diff] = dic[j][diff] +
                 longest = max(longest,dic[i][diff])
         return longest

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

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

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

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