hdu-1087 Super Jupmping ! Jumping ! Jumping

基础之基础之中的基础，然而很简单

简单的动态规划，最长上升子序列 LIS（Longest Increasing Subsequence)

dp[i]表示第i个数结尾的最长上升子序列的长度

初始是dp[i]=1;seg[i]储存第i个数；

求第 i 个的最长LIS 就是求 max j （< i）的LIS加上 1，

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

如果seg[j]<seg[i]并且j<i的话，就更新，取最大值；

这个题用的是值，每次更新的时候取值最大的，

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

int n;
const int maxn=1e3+5;
int dp[maxn],seg[maxn];

int main(){
    while(scanf("%d",&n)!=EOF&&n){
        for(int i=0;i<n;i++)
            scanf("%d",&seg[i]);
        int ans=0;
        for(int i=0;i<n;i++){
            dp[i]=seg[i];
            for(int j=0;j<i;j++){
                if(dp[i]<dp[j]+seg[i]&&seg[j]<seg[i]){
                    dp[i]=max(dp[i],dp[j]+seg[i]);
                }
            }
            ans=max(ans,dp[i]);
        }
        printf("%d\n",ans);
    }
    return 0;
}

上面的这个时间复杂度(n*n）,

还有一种时间复杂度为（nlogn）的做法，用一个栈来维护一个从大到小的数列

对于当前的数 x 如果大于栈顶的元素的话，就加入栈，

否则的话就在当前的栈内二分查找第一个大于或等于 x 的数，并替换它，

int a[maxn];
int stack[maxn];//储存最大上升子序列的栈
int top;//栈顶
int l;//数组的长度

void solve(){
    top=0,stack[top]=-INF;
    for(int i=1;i<=l;i++){
        int t=stack[top];
        if(a[i]>t) stack[++top]=t;
        else {
            int ls=0,rs=top;//二分搜索第一个大于等于a[i ]的元素
            while(rs-ls>1){
                int mid=(rs+ls)>>1;
                if(stack[mid]>=t) rs=mid;
                else ls=mid;
            }
            stack[rs]=t;
        }
    }
    cout<<top<<endl;//最后所求的top就是最长上升子序列  
}