最长上升/不下降子序列

最长上升/不下降子序列：(LIS)

有两种方法：

1.动态规划，O(n^2)

容易得出O(n^2)的DP递推公式：D[i]=max{D[j]}+1;(1<=j<i且E[j]<E[i])

D[i]为以元素i结尾的最长子序列个数。

这样经过两重循环一次遍历可以得到最长上升子序列。

代码：

#include <iostream>
#include <stdio.h>
#include <cstring>
using namespace std;
const int maxnum=100;
int a[maxnum],dp[maxnum];

int main()
{
    int n,i,j;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
        dp[i]=1;
    }

    for(i=1;i<n;i++)
        for(j=0;j<i;j++)
            if(a[j]<=a[i])
                dp[i]=max(dp[i],dp[j]+1);

    int ans=dp[0];
    cout<<dp[0]<<" ";
    for(i=1;i<n;i++)
    {
        cout<<dp[i]<<" ";
        if(ans<dp[i])
            ans=dp[i];
    }
    cout<<endl;
    printf("%d!!\n",ans);
    return 0;
}
/*
7
3 2 5 4 4 6 7
*/

2.二分查找法，CMI算法，O(nlogn)
操作：

开辟一个栈b，每次取栈顶元素s和读到的元素a做比较，如果a>s，则置为栈顶；如果a<s，则二分查找栈中的比a大的第1个数，并替换。最终栈的大小即为最长递增子序列为长度。

考察b栈内每个元素的含义,b[i] 表示所有长度为i的上升子序列中最后一个数最小的

举例：原序列为3，4，5，2，4，2

 栈为3，4，5，此时读到2，则用2替换3，得到栈中元素为2，4，5，再读4，用4替换5，得到2，4，4，再读2，得到最终栈为2，2，4,最终得到的解是:

 长度为1的上升子序列中最小的最后一个数是2 (2)

 长度为2的上升子序列中最小的最后一个数是2 (2,2)长度为3的上升子序列中最小的最后一个数是4 (3,4,4)

 可知没有长度为4的上升子序列,最长递增子序列长度为3. (3,4,4)

 

 CMI本质是LIS问题的另一种动态规划思路

 注意:CMI只能求LIS的长度和最后一个数,不能求LIS的序列!

代码：

#include <iostream>
#include <stdio.h>
#include <cstring>
using namespace std;
const int maxnum=100;
int a[maxnum];
int stack[maxnum];
int top=-1;

void function(int cur)
{
    int l=0,r=top;
    while(l<=r)
    {
        int m=(l+r)>>1;
        if(stack[m]>=cur)  //递增,stack[m]>cur为非递减
            r=m-1;
        else
            l=m+1;
    }
    if(l>top)
        top=l;
    stack[l]=cur;
}

int main()
{
    int n,i;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
        function(a[i]);
    }
    printf("%d\n",top+1);
    return 0;
}

/*
6
3 4 5 2 4 2
*/