【菜鸟er】动态规划_最长递增子序列

#include <bits/stdc++.h>
using namespace std;
#define MAX_N 100
int a[MAX_N];
int dp[MAX_N][MAX_N];
int dpLCS[MAX_N][MAX_N];
int n,m;
//方法1：公共子序列法；
int LCS(void);
//方法2：动态规划算法；
int LISdp(void);
//方法3：nLGn算法
int nlgn(void);
int DP[MAX_N];//动态规划数组
int len;//标记DP[]内有效元素个数
int er_search(int w);//返回dp数组处理位置的二分搜索
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)    cin>>a[i];

    int x1 = LCS();
    cout<<x1<<endl;

    int x2 = LISdp();
    cout<<x2<<endl;

    int x3 = nlgn();
    cout<<x3<<endl;
    return 0;
}
/**
data:
6
5 6 7 1 2 8
print:4
*/
int LCS(void)
{
    int b[MAX_N];
    memset(b,0,sizeof(int));
    for(int i=0;i<n;i++){
        b[i]=a[i];
    }
    sort(b,b+n);

     for(int i = 0;i<n;i++){
        for(int j = 0;j<n;j++){
            if(a[i] == b[j]){
                dpLCS[i+1][j+1] = dpLCS[i][j]+1;
            }
            else{
                dpLCS[i+1][j+1] = max(dpLCS[i+1][j], dpLCS[i][j+1]);
            }
        }
    }
    return dpLCS[n][n];

}

int LISdp(void)
{
    int dp[MAX_N]={0};
    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);
            }
        }
    }
    int maxlen=0;
    for(int i = 0;i<n;i++){
        if(dp[i]>maxlen) maxlen = dp[i];
        //cout<<dp[i]<<" ";
    }
    return maxlen;
}
/**
DP[]存储对应长度LIS的最小末尾。
**/
int nlgn(void)
{
    len = 1;//dp长度标记
    DP[0] = a[0];//初始化第一个
    int pos=0;//临时下标

    for(int i = 0;i<n;i++){
        if(a[i]>DP[len-1]){//如果大于就在后面接上
            DP[len] = a[i];
            ++len;
        }
        else{//否则准备插入
            pos = er_search(a[i]);
            DP[pos] = a[i];
        }
    }
    return len;//返回长度
}
int er_search(int w)
{
    int left=0,right=len-1;
    int mid;

    while(left <= right){
        mid = (left+right)/2;
        //左右逼近，获得下标
        if(DP[mid]>w)    right = mid-1;
        else if(DP[mid]<w)   left = mid + 1;
        else return mid;
    }
    return left;//由于与数组左边比较，所以返回左下标
}