leetcode1027

最直接的思路是三層循環，可是會超時，代碼以下：

 1 public class Solution  2  {  3         public int LongestArithSeqLength2(int[] A)  4  {  5             var maxLength = 2;  6             var len = A.Count();  7             for (var i = 0; i < len; i++)  8  {  9                 for (var j = i + 1; j < len; j++) 10  { 11                     var curmax = 2; 12                     var target = A[i] - A[j]; 13                     var next = A[j] - target; 14                     for (var k = j + 1; k < len; k++) 15  { 16                         if (A[k] == next) 17  { 18                             curmax++; 19                             next = A[k] - target; 20  } 21 
22  } 23                     maxLength = Math.Max(maxLength, curmax); 24  } 25  } 26             return maxLength; 27  } 28     }

但一樣的代碼，使用java實現，卻能夠正常提交，leetcode對這道題目的的判斷機制有點奇怪。

若是想解決超時問題，能夠考慮使用哈希或者dp思想，來減小判斷的時間。

這種題目，作起來很麻煩，看看別人的思路吧。

 

當時沒想出來怎麼作，通過一段時間的練習(兩個半月)，從新作這道題目，順利作出來了，說明練習仍是有效果的。

給出一份python的實現：

 1 class Solution:  2     def longestArithSeqLength(self, A: 'List[int]') -> int:  3         n = len(A)  4         if n == 2:  5             return 2
 6         dic = {0:{0:1}}  7         longest = 0
 8         for i in range(1,n):  9             if i not in dic: 10                 dic[i] = {0:1} 11             for j in range(i): 12                 diff = A[i] - A[j] 13                 if diff not in dic[j]: 14                     dic[i][diff] = 2
15                 else: 16                     dic[i][diff] = dic[j][diff] + 1
17                 longest = max(longest,dic[i][diff]) 18         return longest

使用hash緩存以前的記錄，從三層循環減小爲兩層循環，時間複雜度爲O(n^2)，可是增長了空間複雜度。典型的用空間換時間的思想。

dic是一個字典，key值是數組的下標，value值是一個字典類型。

這個value字典，key值是int類型，表示兩項之間的差；value值是int類型，表示這個差值造成的等差數列的長度。

所以每次循環用longest記錄任意一個差值所造成的最長的等差數列的長度，即爲所求。