HZAU 21——Arithmetic Sequence——————【暴力 or dp】

Arithmetic Sequence

Time Limit: 1 Sec  Memory Limit: 128 MB
Submit: 1810  Solved: 311
[Submit][Status][Web Board]

Description

Giving a number sequence A with length n, you should choosing m numbers from A(ignore the order) which can form an arithmetic sequence and make m as large as possible.

Input

There are multiple test cases. In each test case, the first line contains a positive integer n. The second line contains n integers separated by spaces, indicating the number sequence A. All the integers are positive and not more than 2000. The input will end by EOF.

Output

For each test case, output the maximum  as the answer in one line.

Sample Input

5
1 3 5 7 10
8
4 2 7 11 3 1 9 5

Sample Output

4
6

HINT

In the first test case, you should choose 1,3,5,7 to form the arithmetic sequence and its length is 4.

In the second test case, you should choose 1,3,5,7,9,11 and the length is 6.

 

 

题目大意：给你n个数，让你从n个数中找到最长的等差数列。

 

解题思路：比赛时候，想到了要枚举数列第一项，然后枚举公差，然后还要枚举点什么，所以感觉时间可能会爆，然后就想dp，dp也是想不到怎么优化，当时的想法就是要n^3所以也不敢写，还是不够confident。其实暴力也很简单，只要标记一下有没有这个数字，如果有，就可以往后暴力找，如果没有，就枚举下一个公差。dp的技巧性比较强，由于dp[i][j]表示以a[i]结尾的公差为j的等差数列长度，所以需要记录前面出现的a的下标，很巧妙。

 

 

暴力做法：

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
#include<string>
#include<iostream>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<set>
using namespace std;
typedef long long LL;
#define mid (L+R)/2
#define lson rt*2,L,mid
#define rson rt*2+1,mid+1,R
const int maxn = 1e3 + 30;
const LL INF = 0x3f3f3f3f;
const LL mod = 9973;
typedef long long  LL;
typedef unsigned long long ULL;
int cnt[maxn], a[maxn];
int main(){
    int n;
    while(scanf("%d",&n)!=EOF){
        memset(cnt,0,sizeof(cnt));
        for(int i = 1; i <= n; ++i){
            scanf("%d",&a[i]);
            cnt[a[i]]++;
        }
        sort(a+1,a+1+n);
        int ans = 1;
        for(int i = 1; i <= n; ++i){ //enum the first item
            if(cnt[a[i]] > n-i+1){
                ans = max(ans, cnt[a[i]]);
                break;
            }
            for(int j = 1; a[i] + j <= a[n]; ++j){
                int d = j, c = a[i], len = 1;
                while(cnt[c+d]){
                    c += d;
                    len++;
                }
                ans = max(ans, len);
            }
        }
        printf("%d\n",ans);

    }
    return 0;
}

　　

dp做法：

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
#include<string>
#include<iostream>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<set>
using namespace std;
typedef long long LL;
#define mid (L+R)/2
#define lson rt*2,L,mid
#define rson rt*2+1,mid+1,R
const int maxn = 1e3 + 30;
const LL INF = 0x3f3f3f3f;
const LL mod = 9973;
typedef long long  LL;
typedef unsigned long long ULL;

int dp[maxn*2][maxn*2], a[2*maxn], idx[2*maxn]; //dp[i][j] meaning the length that ending up with a[i], common dif is j
int main(){
    int n;
    while(scanf("%d",&n)!=EOF){
        int Max = 0;
        for(int i = 1; i <= n; ++i){
            scanf("%d",&a[i]);
            Max = Max < a[i] ? a[i]:Max;
        }
        sort(a+1,a+1+n);
        for(int i = 1; i <= n; ++i){
            for(int j = 0; j <= Max; ++j){
                dp[i][j] = 1;
            }
        }
        memset(idx,0,sizeof(idx));
        int res = 1;
        for(int i = 1; i <= n; ++i){
            for(int j = 0; j <= Max; ++j){
                if(a[i] > j){
                    dp[i][j] = dp[idx[a[i]-j]][j] + 1;
                }
                res = max(res, dp[i][j]);
            }
            idx[a[i]] = i;
        }
        printf("%d\n",res);
    }
    return 0;
}