求数组中最长递增子序列

数组中最长递增子序列：如在序列1,-1,2,-3,4,-5,6,-7中，最长递增序列为1,2,4,6。

时间复杂度O(N^2)的算法：

LIS[i]：表示数组前i个元素中（包括第i个），最长递增子序列的长度

LIS[i] = max{ 1, LIS[k]+1 }, 0 <= k < i, a[i]>a[k]

int LIS(int a[], int length)
{
    int *LIS = new int[length];
    for(int i = 0; i < length; ++i)
    {
        LIS[i] = 1; //初始化默认长度
        for(int j = 0; j < i; ++j) //前面最长的序列
            if(a[i] > a[j] && LIS[j]+1 > LIS[i])
                LIS[i] = LIS[j]+1;  
    }
    int max_lis = LIS[0];
    for(int i = 1; i < length; ++i)
        if(LIS[i] > max_lis)
            max_lis = LIS[i];
    return max_lis;  //取LIS的最大值
}

时间复杂度O(NlogN)的算法：
辅助数组b[]，用k表示数组b[]目前的长度，算法完成后k的值即为LIS的长度。
初始化：b[0] = a[0]，k = 1
从前到后扫描数组a[]，对于当前的数a[i]，比较a[i]和b[k-1]：
如果a[i]>b[k-1]，即a[i]大于b[]最后一个元素，b[]的长度增加1，b[k++]=a[i]；
如果a[i]
LIS的长度为k

//修改的二分搜索算法，若要查找的数w在长为len的数组b中存在则返回下标
//若不存在，则返回b数组中的第一个大于w的那个元素的下标
int BiSearch(int *b, int len, int w)
{
    int left = 0, right = len-1;
    int middle;
    while(left <= right)
    {
        middle = (left+right)/2;
        if(b[middle] > w)
            right = middle - 1;
        else if(b[middle] < w)
            left = middle + 1;
        else
            return middle;
    }

    //返回b数组中的刚刚大于w的那个元素的下标
    return (b[middle]>w) ? middle : middle+1;
}

int LIS(int *array, int n)
{
    int *B = new int[n];
    int len = 1;
    B[0] = array[0];

    for(int i=1; i B[len-1])
        {
            B[len] = array[i];
            ++len;
        }
        else
        {
            int pos = BiSearch(B, len, array[i]);
            B[pos] = array[i];
        }
    }
    delete []B;
    return len;
}