Longest Ordered Subsequence POJ - 2533 （最长上升子序列）

Longest Ordered Subsequence

POJ - 2533

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

两种方法第一种复杂度n^2,第二种复杂度n(long)n

第一种把每个字符作为上升子序列的结束字符，因为以ai结尾的上升子序列的是①只包含ai一个字符的序列②在满足j<i&&aj<ai的上升序列的末尾，追加上ai之后得到的序列。

这两者之一。

这样就能得到下面的递推式：

dp[i]=max{1,dp[j]+1}

使用这个公式复杂度是n^2;

代码：

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

const int manx=10000;

int s[5000];
int dp[5000];
int n;
void readin()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d",&s[i]);
    }
}
void Init()
{
    memset(s,0,sizeof(s));
}
void solve()
{
    int ans=0;
    for(int i=0;i<n;i++)
    {

        dp[i]=1;
        for(int j=0;j<i;j++)
        {
            if(s[i]>s[j])
            {
                dp[i]=max(dp[i],dp[j]+1);
            }
        }
        ans=max(ans,dp[i]);
    }
    printf("%d\n",ans);
}
int main ()
{
    Init();
    readin();
    solve();
    return 0;
}

第二种：

dp[i]=长度为i+1的上升子序列中末尾元素的最小值（不存在的话就是INF）

最开始的dp[i]全都初始化为INF。然后有前到后的考虑数列的元素对于每个aj如果i=0或者dp[i-1]<aj的话就用dp[i]=min(dp[i],aj)进行更新。最终找出使得dp[i]<INF的最大的i+1就是结果了，这个算法 直接进行的话复杂度也是n^2，但是这一算法可以优化，首先dp数列中出了INF都是递增的，所以我们知道对于每个aj最多只需要一次更新，对于更新的位置可以二分，这样就可以在nlongn内得出结果。   

代码：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
#define INF 100000000
using namespace std;
const int manx=10000;
int s[5000];
int dp[5000];
int n;
void readin()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
    {
        scanf("%d",&s[i]);
    }
}
void Init()
{
    memset(s,0,sizeof(s));
}
void solve()
{
    int ans=0;
    for(int i=0;i<n;i++)
    {

        dp[i]=1;
        for(int j=0;j<i;j++)
        {
            if(s[i]>s[j])
            {
                dp[i]=max(dp[i],dp[j]+1);
            }
        }
        ans=max(ans,dp[i]);
    }
    printf("%d\n",ans);
}
void solve1()
{
    fill(dp,dp+n,INF);
    for(int i=0;i<n;i++)
    {
        *(lower_bound(dp,dp+n,s[i]))=s[i];
    }
    printf("%d\n",lower_bound(dp,dp+n,INF)-dp);
}
int main ()
{
//    Init();
    readin();
    solve1();
    return 0;
}