Gym 102082B : Arithmetic Progressions

戳这里看题目吧！

题目大意：给你一个长度为n(2<=n<=5000)的序列，没有重复的数字，序列中每个元素满足(0<=num_i<=1e9)。求一个最长的数列满足差分值相同（除n=2外，可以看成等差数列）。输出这个最大长度。

算法梗概：DP。看了几篇博客都说算是个板子套路DP题。在做的时候也想到了DP，但是没找对状态。

　　　　　另外可以用其他算法来做这道题，后面慢慢补。先给出DP算法的代码和思路。

 #include<cstdio>
 #include<algorithm>
 const int maxn = 5e3 + ;
 int dp[maxn][maxn],n,num[maxn];
 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;++i){
         scanf("%d",num+i);
         for(int j=;j<=n;++j){
             dp[i][j] = ;
         }
     }
     std::sort(num+,num++n);
     int ans = ;
     for(int i=;i<=n-;++i){
         int pre = i - ;
         for(int j=i+;j<=n;++j){
         　　///令d=num[j] - num[i],因为序列是递增的，所以num[i] - num[pre]在pre刚开始不满足条件时大于d，在pre刚好满足条件时等于d，继续遍历则小于d，后来的遍历是无意义的所以跳出即可
         　　while(pre >  && num[j] - num[i] > num[i] - num[pre]) pre--;
         　　if(pre==) break;
         　　else if(pre >  && num[j] - num[i] == num[i] - num[pre]) dp[i][j] = std::max(dp[i][j],dp[pre][i]+);
         　　ans = std::max(ans,dp[i][j]);
         }
     }
     printf("%d\n",ans);
     return ;
 }

DP思路：dp[i][j]表示已下标i，j（i<j）为结尾两个元素的一个子序列的长。枚举i，以i+1开始向后遍历j，这样对于每对i，j我们可以求出他们的差，以这个差为标准，从i-1开始向前遍历记为pre，直到找到的pre和i，j满足num[j] - num[i] == num[i] - num[pre]。如果找到这样的num[pre]更新dp[i][j]即可。

状态转移方程：dp[i][j] = max(dp[i][j],dp[pre][i]+1)

---

直接用用等差数列的通项公式来暴力

 #include <cstdio>
 #include <algorithm>
 #include <set>
 using namespace std;
 const int maxn  = 5e3+;
 int num[maxn],n;
 set<int> se;
 int main()
 {
     scanf("%d",&n);
     for(int i = ; i<=n; ++i)
     {
         scanf("%d",num+i);
         se.insert(num[i]);
     }
     sort(num+,num+n+);
     int ans = ,d,k;
     for(int i=;i<=n;++i)
     {
         for(int j=i+;j<=n;++j)
         {
             k = ,d = num[j] - num[i];
             if(!se.count(num[i] + ans*d)) continue;
             while(se.count(num[i] + k*d)) k++;
             ans = max(ans,k);
         }
         if(ans==n) break;
     }
     printf("%d\n",ans);
     return ;
 }

核心代码：

     k = ,d = num[j] - num[i];
     if(!se.count(num[i] + ans*d)) continue;
     while(se.count(num[i] + k*d)) k++;
     ans = max(ans,k);

暴力思路：a_k = a₁ + (k-1)d;

　　　　　两层for循环来枚举a₁和d，对于每对<a₁,d>,枚举k来得到一个a_k，判断a_k是不是存在在序列中，存在继续枚举，否则更新答案。

请注意！！！  if(!se.count(num[i] + ans*d)) continue; 这行代码的作用，对于你已经更新到的答案ans，如果num[i] + ans*d都不存在，那么无法更新答案，所以跳过这层循环。

没有这行代码会TLE在test 57或者test 58，做题就死在了这里了。

---

还有些同学用了二分函数，其实和暴力的核心思想差不多，用二分函数优化很多，这里只给代码，不解释了如果暴力看懂了这个也就懂了

 #include<cstdio>
 #include<algorithm>
 const int maxn = 5e3 + ;
 int dp[maxn][maxn],n,num[maxn];
 int main()
 {
     scanf("%d",&n);
     for(int i=;i<=n;++i) scanf("%d",num+i);
     std::sort(num+,num++n);

     int ans = ,res,d,pos;
     for(int i=;i<=n-;++i){
         for(int j=i+;j<=n;++j){
             d = num[j] - num[i];
             res = ;
             pos = std::lower_bound(num+j+,num+n+,num[i]+ans*d) - num;
             if(num[pos]!=num[i]+ans*d) continue;
             for(int k=j;k<=n-;){
                 pos = std::lower_bound(num+k+,num+n+,num[k]+d) - num;
                 if(num[pos]==num[k]+d){
                     k = pos;
                     res++;
                 }
                 else break;
             }
             ans = std::max(ans,res);
         }
     }
     printf("%d\n",ans);
     return ;
 }

This’s all！如有错误，请评论指正谢谢！！