AOJ-AHU-OJ-497 最长起伏子序列

最长起伏子序列

Time Limit: 1000 ms   Case Time Limit: 1000 ms   Memory Limit: 64 MB

Description

我们先介绍一下最长递增（递减）子序列的概念，子序列的定义在数学书上介绍过了，严格的定义就不说了，大概意思就是序列S中部分元素组成的序列，当然顺序要保持一致，注意子序列并不要求元素连续相邻。最长递增（递减）子序列顾名思义就是递增且最长的一个子序列。
还不太明白？没关系，举个例子就清楚了。
例如： 序列S = 1,5,3,2,4,6,3
最长递增子序列有 1,3,4,6 和 1,2,4,6 两个，长度都是4

当然这个经典的问题网上有很多很多的代码，所以当然不会考这个啦！
我们稍微做了一点变动，求最长起伏子序列的长度。
所谓起伏就是任意元素的前后元素必须都比他大或者同都比他小，序列呈锯齿状，高低起伏。

例如，序列S2 = 1,4,2,3,7,3,6
最长起伏子序列就是： 1,4,2,7,3,6 长度为6

Input

对于第N组测试数据：
第2N-1行：序列长度L （1<=L<=5000）,当L为0时测试结束
第2N行：序列S，元素Si（0<=Si<=2³¹-1）用空格隔开

Output

每组数据输出一行，第N组数据格式如下：
第N行：一个整数x，代表第N个序列S的最大起伏子序列的长度

Sample Input

Original

Transformed

7
1 4 2 3 7 3 6
4
4 3 2 3
0

Sample Output

Original

Transformed

6
3

Source

小兔齐齐

————————————————————AHU的分割线————————————————————

思路：这其实就是最长上升子序列的变种。但是我目前只能给出O(n^2)的做法。状态转移略微发生了变化。事先并不清楚第一个元素开始先上升的长还是先下降的长。我的办法是用两个数组，dp[ ]和dq[ ]一个是先上升一个是先下降。

然后思考一下，怎样起伏呢？很简单，如果前 i - 1 个元素能够成的最长子序列长度是奇数，那么、、、如果是偶数那么、、、先不看是否符合增减性，（因为两种可能都可以成立），先看如果转移过来，子序列会不会变长，然后分奇偶，看是否符合增减性。

代码如下：

/****************************************/
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #include <cmath>
 #include <stack>
 #include <queue>
 #include <vector>
 #include <map>
 #include <string>
 #include <iostream>
 using namespace std;
/****************************************/
const int N = 5005;
int sq[N];
int dp[N], dq[N];
 
int main()
{
    int n;
    while(~scanf("%d", &n)) {
        if(!n)  break;
        int ans = 0;
        for(int i = 0; i < n; i++) {
            scanf("%d", &sq[i]);
            dp[i] = dq[i] = 1;
            for(int j = 0; j < i; j++) {
                if(dp[i] < dp[j] + 1) {
                    if(dp[j]&1) {
                        if(sq[j] < sq[i])
                            dp[i] = dp[j] + 1;
                    }
                    else {
                        if(sq[j] > sq[i])
                            dp[i] = dp[j] + 1;
                    }
                }
                if(dq[i] < dq[j] + 1) {
                    if(dq[j]&1) {
                        if(sq[j] > sq[i])
                            dq[i] = dq[j] + 1;
                    }
                    else {
                        if(sq[j] < sq[i])
                            dq[i] = dq[j] + 1;
                    }
                }
            }
            ans = max(ans, dp[i]);
            ans = max(ans, dq[i]);
        }
        printf("%d\n", ans);
    }
    return 0;
}

另一种方法：其实并不需要分类讨论。

如果上升，则从上次下降的数组转移过来，如果下降，则从上次上升的数组转移过来，这么一交替转移，代码就变得更加简洁明了了。

代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 5005;
int sq[N];
int dp[N], dq[N];
 
int main()
{
    int n;
    while(~scanf("%d", &n)) {
        if(!n)  break;
        int ans = 0;
        for(int i = 0; i < n; i++) {
            scanf("%d", &sq[i]);
            dp[i] = dq[i] = 1;
            for(int j = 0; j < i; j++) {
                if(sq[i] > sq[j])
                    dp[i] = max(dp[i], dq[j]+1);
                if(sq[i] < sq[j])
                    dq[i] = max(dq[i], dp[j]+1);
            }
            ans = max(ans, dp[i]);
            ans = max(ans, dq[i]);
        }
        printf("%d\n", ans);
    }
    return 0;
}