最长等差数列_(Trivial) LeetCode 1027

关键字：动态规划

归航return：(Trivial) LeetCode 1020—飞地的数量zhuanlan.zhihu.com

归航return：LeetCode 1316—不同的循环字符串zhuanlan.zhihu.com

Problem

Given an array A of integers, return the length of the longest arithmetic subsequence in A.

Recall that a subsequence of A is a list A[i_1], A[i_2], ..., A[i_k] with 0 <= i_1 < i_2 < ... < i_k <= A.length - 1, and that a sequence B is arithmetic if B[i+1] - B[i] are all the same value (for 0 <= i < B.length - 1).

Example 1:

Input: [3,6,9,12]
Output: 4
Explanation:
The whole array is an arithmetic sequence with steps of length = 3.

Example 2:

Input: [9,4,7,2,10]
Output: 3
Explanation:
The longest arithmetic subsequence is [4,7,10].

Example 3:

Input: [20,1,15,3,10,5,8]
Output: 4
Explanation:
The longest arithmetic subsequence is [20,15,10,5].

Note:

2 <= A.length <= 2000
0 <= A[i] <= 10000

1027. 最长等差数列 - 力扣（LeetCode）leetcode-cn.com

Solution

这道题目的 tag 是动态规划，既然是 DP，那么最重要的就是确定 base case 和 state transition equation。让我们回顾一下等差数列的性质：一个数列是等差数列，当且仅当数列的长度大于等于 2，而且一阶差分全部相等。此处的一阶差分的长度会比原来的数组长度小 1，而不是 C++ 中的 adjacent_difference 函数。那么既然长度大于等于 2，那么不管等差子序列长度多长，这个等差子序列一定存在最后两项，利用这个就可以建立一个动态规划关系。

定义一个二维的 dp 数组，其中 dp[i][j] 是等差子序列中，最后两项是 nums[i] 和 nums[j] 的情况下，最长的子序列长度，显然，这里自带一个约束，就是 i < j。

首先考虑 base case。显然，上述所有的 dp[i][j] ，都必然有 dp[i][j] >= 2。那么什么时候一定取等号呢？显然，当 i == 0 的时候，由于下标最小为 0，我们不可能继续往前延展等差序列，因此 dp[0][j] = 2，其中 1 <= j < nums.length。这是一个非常 well-defined 的 base case。

之后就是考虑状态转移关系。当我们确定了等差数列的最后两项之后，理论上，如果前面还有若干项，而且我们知道项数，那么等差数列就已经被唯一地确定了，因为等差数列有熟知的通项公式

，其中

为公差。所以，如果之前还有若干项，那么等差数列的最后三项一定是等差数列。如果我们能在

nums[i] 之前找到某一项 nums[m]，使得 nums[m] ，nums[i]，nums[j] 成等差数列，那么可以将用 nums[m] 和 nums[i] 结尾的等差数列的结尾加上 nums[j]，作为 dp[i][j] 的候选。另外，即使找不到，那么 nums[i] 和 nums[j] 本身也可以组成一个长度为 2 的等差数列。综上所述，整个问题的状态转移方程是：

Java 代码如下：

class Solution {public int longestArithSeqLength(int[] A) {if (A.length <= 2){return 2;}if (A.length == 3){return A[2]-A[1] == A[1]-A[0] ? 3 : 2;}int n = A.length;int[][] dp = new int[n][n];//definition: the longest subsequence whose last two nums are A[i] and A[j] with constraint i is less than jfor (int i = 0; i < n; ++i){for (int j = i+1; j < n; ++j){dp[i][j] = 2;//obviously, any subsequence whose length is two is arithmetic//Specially, if the second last num is A[0], there can be no more nums chosen because any access to index less than 0 is illegal}}int res = 2;for (int i = 1; i < n; ++i){for (int j = i+1; j < n; ++j){//compute dp[i][j]for (int m = 0; m < i; ++m){if (A[j]-A[i] == A[i]-A[m]){dp[i][j] = Math.max(dp[i][j], dp[m][i]+1);//If A[j]-A[i] == A[i]-A[m], it means the longest subsequence may be the longest subsequence //whose last two nums are A[m] and A[i], with A[j] appended to the end.}}res = Math.max(dp[i][j], res);}}return res;}
}

这个算法的时间复杂度是 O(n^3)，不过题目给出的数据规模是 2K，虽然理论上可能有点悬，但是有惊无险，过了。（经过测试发现，如果输入数组的长度是 2000，则在最后一个 for 循环中需要运算 1331334000 次，这已经超过了通常而言 C++/Java 等语言允许的计算次数上限 10^8 这个数量级了。

一个容易注意到的优化点是，每次查找的时候，我们需要用 O(n)的时间去查找是否有可以连缀成更长的等差数列的情况。然而事实上，如果给定一个长度为 3 的等差数列，其中第一项和第二项分别是 b 和 c，那么第 0 项一定是 a = 2*b-c，这是高中的时候老师说烂了的知识点。

因此不去穷举，而是使用 Hash 表，就可以直接 O(1) 时间就能找到是否能符合要求了。当然，为了能得到 m ，这个 Hash 表应当是 C++ 中的 std::unordered_map，或者 Java 中的 HashMap。C++ 代码如下：

class Solution {public:int longestArithSeqLength(vector<int>& A) {if (A.size() == 2){return 2;}if (A.size() == 3){return A[2]-A[1] == A[1]-A[0];}int n = A.size();vector<vector<int>> dp(n, vector<int>(n, 2));unordered_map<int, vector<int>> cntHashMap;for (int i = 0; i < n; ++i){cntHashMap[A[i]].emplace_back(i);}int res = 2;for (int i = 1; i < n; ++i){for (int j = i+1; j < n; ++j){if (cntHashMap.count(2*A[i]-A[j])){for (const auto m : cntHashMap[2*A[i]-A[j]]){if (m < i){dp[i][j] = max(dp[i][j], dp[m][i]+1);}else{break;}}res = max(res, dp[i][j]);}}}return res;}
};

这个算法打败了 94.39% 的 C++ 提交，可见速度的差异——当然也是和测试用例相关，当数据量增大的时候，Hash 表的优势才能体现出来。

EOF。