最长上升子序列nlogn及n^2算法

这题目是经典的DP题目，也可叫作LIS（Longest Increasing Subsequence）最长上升子序列 或者 最长不下降子序列。很基础的题目，有两种算法，复杂度分别为O(n*logn)和O(n^2) 。看了很多篇博客进行的总结，非常好理解，非常值得学习！！！代码对应leetcode300题。

A.
O(n^2)算法分析如下： 
（a[1]...a[n] 存的都是输入的数） 
1、对于a[n]来说，由于它是最后一个数，所以当从a[n]开始查找时，只存在长度为1的不下降子序列； 

 

2、若从a[n-1]开始查找，则存在下面的两种可能性： 
   （1）若a[n-1] < a[n] 则存在长度为2的不下降子序列 a[n-1],a[n];
   （2）若a[n-1] > a[n] 则存在长度为1的不下降子序列 a[n-1]或者a[n]。 

 

3、一般若从a[t]开始，此时最长不下降子序列应该是按下列方法求出的： 
    在a[t+1],a[t+2],...a[n]中，找出一个比a[t]大的且最长的不下降子序列，作为它的后继。 

 4、用dp[t]表示第t个元素的最长上升子序列的长度，那么状态转移方程为：

   dp[t]=max{dp[i]+1},a[i]<a[t]&&i=1,2,...,t-1

 

实现代码如下：

// 最长上升子序列.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
#include <vector>

using namespace std;

int lengthOfLIS(vector<int>& nums) {
	//O(n^2)
	int i = 0, j = 0, max = 0;
	vector<int> vecb(nums.size(), 1);//相当于b[i] 用来记录当前第i位数的 最长上升序列的长度
	for (i = 1; i < nums.size(); i++){
		for (j = 0; j < i; j++){
			if (nums[j]<nums[i] && vecb[j] + 1>vecb[i]){
				vecb[i] = vecb[j] + 1;
			}
		}
	}
	for (i = 0; i < nums.size(); i++){
		if (vecb[i]>max)
			max = vecb[i];
	}
	return max;
}

int main()
{
	vector<int> vec = {10,9,2,5,3,7,101,18};
	cout<<lengthOfLIS(vec)<<endl;
	return 0;
}

显然，这种方法的时间复杂度仍为o(n^2);

B.

最长不下降子序列的O(nlogn)算法分析如下: 
还有更好的方法，使得时间复杂度能更高，为nlogn，用栈，比较好理解。

其实这个算法已经算不上DP了，有点像贪心。至于复杂度降低其实是因为这个算法里面用到了二分搜索，本来有n个数要处理是O(n),每次计算要查找n次还是O（n），一共就是O(n^2)；现在搜索换成了O(nlogn)的二分，总的复杂度就变成了O(nlogn)了。

这个算法的具体操作如下：

开一个栈，每次取栈顶元素Top和读到的元素tmp做比较，如果tmp>Top，则将tmp入栈；如果tmp<Top 则二分查找栈中的比tmp大的第一个数，并用tmo替换它。最长序列的长度即为栈的大小Top。

这也是很好理解的，对于x和y，如果x<y&&Stack[y]>Stack[x]，用Stack[x]替换Stack[y]，此时的最长序列长度没有改变但是序列Q的“潜力”增大了。

举个例子，原序列为1,5,8,3,6,7 

栈为1,5,8 此时读到了3，因为3<8，那么二分，用3替换5，得到1,3,8;再读6,用6替换8，得到1,3,6；再读7，得到最终栈为1,3,6,7.最长递增子序列为长度4.

或许你会想，当出现1,5,8,3这种情况时，栈内最后的数是1,3,8 不是正确的序列啊？  难道错了？ 

分析一下，我们可以看出，虽然有时候得不到正确的序列，但是最后算出来的序列个数是没错的，为什么呢？

想想，当tmp>Top时，总个数直接+1，这肯定没错；但是tmp<Top呢？这时tmp肯定只是替换了栈里面的某一个元素，所以大小不变，就是说一个小于栈顶的元素加入时，总个数是不变的。

这两种情况的分析可以看出，如果只求个数的话，这个算法还是比较高效的，但是要求打印出序列时，就只能用A算法了。

B算法的代码：

int lengthOfLIS(vector<int>& nums) {
	//O(nlogn)
	int i, n, top = 0;
	vector<long long> stack(nums.size()+1);
	stack[0] = 0-INT_MAX-1;//定义一个栈
	for (i = 0; i<nums.size(); i++){
		//比栈顶元素大的就入栈
		if (nums[i]>stack[top]){
			stack[++top] = nums[i];
		}
		else{
			int low = 1, high = top;
			int mid;
			//二分检索比栈中比tmp大的第一个数
			while (low <= high){
				mid = (low + high) / 2;
				if (nums[i] > stack[mid]){
					low = mid + 1;
				}
				else{
					high = mid - 1;
				}
			}
			//用tmp替换
			stack[low] = nums[i];
		}
	}
	//最长序列数就是栈的大小
	return top;
}
int main()
{
	vector<int> vec = { 1,2,3};
	cout << lengthOfLIS(vec) << endl;
	return 0;
}