最长递增子序列（LIS）

之前我只知道用dp来找LIS，复杂度为O（n²），但最近学习了一种复杂度为O（nlogn）的方法。

1.dp

用dp[i]=max(dp[j]+1),其中j满足j<i&&a[j]<a[i]条件时，进行转移。

程序如下：

#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int maxn = 1e5 + 10;

int a[maxn];
int dp[maxn];

int main()
{
    int n;
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 0; i < n; i++)
        {
            scanf("%d", &a[i]);
        }
        dp[0] = 1;
        int ma = 1;
        for (int i = 1; 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);
                }
            }
            ma = max(ma, dp[i]);
        }
        printf("%d
", ma);
    }


    return 0;
}

2.算法2

维护一个数组v，保持这个数组单调递增的性质，把原数组a的数按顺序放入到v中，

当a当前的数大于v的最后一个数时，直接把该数添加到v的末尾，

否则就利用二分查找，把数替代v中第一个比它大的数，复杂度O（logn）。

最后v数组的长度为最长递增序列。

而复杂度就是O（nlogn）。

#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;

const int maxn = 1e5 + 10;

int v[maxn];
int a[maxn];

int binary_search(int left, int right, int value)
{  
    while (left <= right)
    {  
        int mid = (right + left) / 2;
        if (v[mid] > value)
        {
            right = mid - 1;
        }  
        else if (v[mid] < value)
        {
            left = mid + 1;
        }  
        else
        {
            return mid;
        }
    }
    return left;
}

int main()
{
    int n;
    while (scanf("%d", &n) != EOF)
    {
        int len = 1;
        for (int i = 0; i < n; i++)
        {
            scanf("%d", &a[i]);
        }
        v[0] = a[0];
        for (int i = 1; i < n; i++)
        {
            if (a[i] > v[len - 1])
            {
                v[len] = a[i];
                len++;
            }
            else
            {
                int p = binary_search(0, len - 1, a[i]);
                v[p] = a[i];
            }
        }
        printf("%d
", len);
    }

    return 0;
}