LIS——最长上升子序列 dp+二分优化

朴素O（n^2)

建立一个数组res[Maxn], res[ i ]用来记录以i位置为结尾的最长的子序列，那么我们要求res这个数组里的最大值（注意不是res[ n ] ），所以当我们在求res[ i ] 时，需要从0到i-1扫一遍，看看通过哪个点“松弛” （因为这个算法好像迪科斯彻最短路，所以借用这个名词来解释一下），这样代码如下

#include<iostream>
#include<algorithm>
using namespace std;
const int MAX=1001;
int a[MAX];
int res[MAX];
int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
    int maxm=0;
    for(int i=0;i<x;i++)
    {
        res[i]=1;
        for(int j=0;j<i;j++)
            if(a[j]<a[i]&&res[j]+1>res[i])
                   res[i]=res[j]+1;
        maxm=max(maxm,res[i]);
    }
    cout<<maxm;
}

二分优化O(nlogn)

借鉴大佬的博客，优化讲的实在太好了！(传送门)

那么，有没有更快的方法呢？当然有。这回要用到二分。

我们回想一下，在上面 O(n2) 的程序中，哪些地方看起来比较费时？

没错，就是内层用于更新i的循环。因为每一次他都要查找一遍，效率并不高。

回到题目，我们发现，他只要我们求长度，所以我们可以模拟一个单调栈（曾经很多参考书说这是一个栈。实际上不是严格的栈，而是一个后进入的加在末尾，然后每次可以替换掉其中元素的序列。这个序列是单调递增的，保证结果就是所求的LIS）。

所以每遇到一个比栈顶元素大的数，就放进栈里，遇到比栈顶元素小的就二分查找前边的元素，找到一个“最应该被换掉的元素”，用新数去更新前边的元素。这个元素可能不是最优解的一部分，但是它可以使得后面还未加入的、比较小的数更有可能进入这个队列。通俗地来说，作为门槛，他本来要大于当前序列的最后一个数才能加进去；就是如果我太大了，我就乖乖呆在末尾；如果前面有一个数比我大，也就是我比你好，既然我在你后面也就是我们两者只能选其一，那我只好把你替换掉了。虽然我这临时临头换的不一定最合适，但是对于后面还有很多的人等着排进来的情况下，我给他们创造了更多机会，使得这个序列的最后一个数有可能变小，让更多的人进来。

这个算法不难证明也是正确的。因为前面每一次的枚举都换成了二分，内层的复杂度从n降到了log2，外层不变。所以总的复杂度是O(nlog2n)。

#include<iostream>
#include<algorithm>
using namespace std;
int v[200001];
int res[200001];
int main()
{
	int n;
	cin>>n;
	for(int i=1;i<=n;i++)
		scanf("%d",&v[i]);
	int len=1;
	res[1]=v[1];
	for(int i=2;i<=n;i++)
	{
		if(res[len]<v[i])
			res[++len]=v[i];
		else
		{
			int j=lower_bound(res+1,res+len+1,v[i])-res;
			res[j]=v[i];
		}
	}
	cout<<len<<endl;
}