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

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

A.

O(n^2)算法分析如下：

（a[1]...a
存的都是输入的数）

1、对于a
来说，由于它是最后一个数，所以当从a
开始查找时，只存在长度为1的不下降子序列；

2、若从a[n-1]开始查找，则存在下面的两种可能性：

（1）若a[n-1] < a
则存在长度为2的不下降子序列 a[n-1],a
;

（2）若a[n-1] > a
则存在长度为1的不下降子序列 a[n-1]或者a
。

3、一般若从a[t]开始，此时最长不下降子序列应该是按下列方法求出的：

在a[t+1],a[t+2],...a
中，找出一个比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;
}