POJ_2533 Longest Ordered Subsequence(DP)

Longest Ordered Subsequence

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 35276		Accepted: 15481

Description

A numeric sequence of  a_i is ordered if  a₁ <  a₂ < ... <  a_N. Let the subsequence of the given numeric sequence ( a₁,  a₂, ...,  a_N) be any sequence ( a_i1,  a_i2, ...,  a_iK), where 1 <=  i₁ <  i₂ < ... <  i_K <=  N. For example, sequence (1, 7, 3, 5, 9, 4, 8) has ordered subsequences, e. g., (1, 7), (3, 4, 8) and many others. All longest ordered subsequences are of length 4, e. g., (1, 3, 5, 8).

Your program, when given the numeric sequence, must find the length of its longest ordered subsequence.

Input

The first line of input file contains the length of sequence N. The second line contains the elements of sequence - N integers in the range from 0 to 10000 each, separated by spaces. 1 <= N <= 1000

Output

Output file must contain a single integer - the length of the longest ordered subsequence of the given sequence.

Sample Input

7
1 7 3 5 9 4 8

Sample Output

4

Source

Northeastern Europe 2002, Far-Eastern Subregion

题意：找到最长上升子串；

题解：这道题是典型的动态规划题目，但是方法有很多，在这里总结一下。

方法1：

n^2

最好想的思路就是对于每个点，若该点最长上升子串长度为dp[i]，找到满足a[i]>a[j]的最大dp[j]，dp[i]等于dp[j]+1；

附代码：

#include <iostream>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
#define MAX_N 1005

using namespace std;

int N,result;
int a[MAX_N],dp[MAX_N];
int main()
{
    cin>>N;
    result = INT_MIN;
    for( int i = 0; i < N; i++ )
        scanf("%d",&a[i]);
    for( int i = 0; i < N; i++ )
    {
        dp[i] = 1;
        for( int j = 0; j < i; j++ )
        {
            if( a[i] > a[j] )
                dp[i] = max( dp[i],dp[j]+1 );
        }
        result = max( result,dp[i] );
    }
    printf("%d\n",result);
    return 0;
}

方法2：

n^2

最长上升子串一定是该数组有序递增排列(删掉重复元素)的子串，转化为昨天做的LCS，比较两数组，找到最长公共子串。

附代码：

#include <stdio.h>
#include <algorithm>
using namespace std;
#define MAXN 1005
int n, i ,j;
int arr[MAXN], sortArr[MAXN], dp[MAXN][MAXN];

int main()
{
    scanf("%d", &n);
    for (i = 0; i < n; i ++){
        scanf("%d", arr + i);
        sortArr[i] = arr[i];
    }
    sort(sortArr, sortArr + n);
    int sortLen = unique(sortArr, sortArr + n) - sortArr;
    for (i = 1; i <= n; i ++){
        for(j = 1; j <= sortLen; j ++){
            if(arr[i-1] == sortArr[j-1]){
                dp[i][j] = dp[i-1][j-1] + 1;
            }
            else{
                dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
            }
        }
    }
    printf("%d\n", dp[n][sortLen]);
    return 0;
}

方法3：

nlogn

用dp[j]存储长度为j+1的上升子序列中末尾元素的最小值(不存在为INF),对于每个aj，用dp[i]=min( dp[i],a[j] )更新，找出dp[i]<IN的最大的i+1就是所求。进一步优化，因为dp数列中除了INF一定是递增的，所以对于每个点aj，只需要更新一次就可以了，在dp数组上二分搜索更新，时间复杂度降为nlogn。

附代码：

#include <iostream>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <cstring>
#include <algorithm>
#define MAX_N 1005

using namespace std;

int N,result;
int a[MAX_N],dp[MAX_N];
int main()
{
    cin>>N;
    result = INT_MIN;
    for( int i = 0; i < N; i++ )
        scanf("%d",&a[i]);
    fill( dp, dp + N, INT_MAX );
    for( int i = 0; i < N; i++ )
        *lower_bound( dp, dp + N, a[i] ) = a[i];
    printf("%d\n",lower_bound( dp, dp + N, INT_MAX )-dp);
    return 0;
}