最长单调递增子序列

       LIS(Longest Increasing Subsequence)问题也是一个经典的动态规划问题，最简单粗暴的方法就是暴力去枚举了，然后就是用动态规划的方法，首先我们要用dp数组去存每一个数前的最长单调递增序列，先初始化dp[]为1,我们要先遍历一遍数组，然后再用一个for循环遍历i之前的数，如果有pre[j]<pre[i]，则有dp[i] = max(dp[i],dp[j]+1),这个也就是LIS的核心代码(动态转移方程)，然后遍历dp求出的最大值即为最长单调递增子序列的长度。

实现代码O(n^2)：

#include <iostream>
#include <cstdio>
#include <cstring>
#define Max(a,b) a>b?a:b
using namespace std;
int pre[100005];
int dp[100005];
int n;

int main()
{
	while(~scanf("%d",&n)){
		for(int i=0;i<n;i++){
			scanf("%d",&pre[i]);
			dp[i] = 1;
		}
		for(int i=1;i<n;i++){
			for(int j=0;j<i;j++){
				if(pre[j] < pre[i])
					dp[i] = Max(dp[i],dp[j] + 1);
			}
		}
		int ans = -1;
		for(int i=0;i<n;i++){
			if(ans < dp[i])ans = dp[i];
		}
		printf("%d\n",ans);
	}
	return 0;
}

       上面这种方法的时间复杂度为O(n^2)，我们还可以用二分的方法对其优化。因为我们只需要求出最长单调递增子序列的长度，所以对其子序列没有要求，我们可以用一个数组来模拟栈，先将第一个数加入到数组中，然后第二个数和这个数(栈顶)比较，如果这个数比栈顶的数大，就把它存入到数组中，如果这个数比栈顶的数小的话，我们就从栈中找第一个比这个数大的数，然后用这个数替换掉第一个比这个数大的数，因为这个数组中的数都是单调的，所以在查找时用二分查找，就把时间复杂度降到了log(n)。可能光看字面理解有点不太好理解，可以去看一下这篇博客，感觉很好理解传送门

实现代码O(n*log(n))：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int main()
{
	int n,m,num;
	int pre[100005];
	while(~scanf("%d",&n)){
		num = 0;
		pre[0] = -100005;
		for(int i=0;i<n;i++){
			scanf("%d",&m);
			if(m > pre[num])pre[++num] = m;
			else{
				int l = 1,r = num,Mid;
				while(l <= r){
					Mid = (l + r) / 2;
					if(m > pre[Mid]) l = Mid + 1;
					else r = Mid - 1;
				}
				pre[l] = m;
			}
		}
		printf("%d\n",num);
	}
	return 0;
}