最长递增子串(LIS)算法_严格单调递增_单调递增_连续_不连续

                                                                                   最长递增子串问题总结

分类

最长递增子串(LIS)，可以按照以下两个属性——是否严格单调递增，是否连续，分成四类：

1.（严格单调递增，连续）

2.（非严格单调递增，连续）

3.（严格单调递增，不连续）

4.（非严格单调递增，不连续）

算法：

情况1，2比较简单，一重循环，可以在O(n)的时间内解决

情况3：

对于每一个num[i]，搜素停在末尾或者>=num[i]的第一个元素的位置处，如果停在dp[b]>=num[i]处，就更新该值，否则，增加找到的的子串的长度。

#include<iostream>
#include<vector>
using namespace std;

int LIS(vector<int> num)
{
	vector<int> dp;
	
	dp.push_back(num[0]);
	
	for(int i=1;i<num.size();++i)
	{
		int b=0,e=dp.size()-1;
		while(b<e)
		{
<span style="color:#cc0000;">			int mid=(b+e)/2;
			if (dp[mid] >= num[i])
				e = mid;
			else
				b = mid+1;</span>
		}
<span style="background-color: rgb(204, 0, 0);">		if(dp[b]>=num[i])
			dp[b]=num[i];
		else 
			dp.push_back(num[i]);</span>
	}
	return dp.size();
}

情况4：

对应每一个num[i],搜索停在末尾或者dp[b]>num[i]处,如果dp[b]>num[i],则更新dp[b],否则增加最长的子串的长度，并加入 num[i]到末尾

<span style="color:#222222;">#include<iostream>
#include<vector>
using namespace std;

int LIS(vector<int> num)
{
	vector<int> dp;
	
	dp.push_back(num[0]);
	
	for(int i=1;i<num.size();++i)
	{
		int b=0,e=dp.size()-1;
		while(b<e)
		{
			int mid=(b+e)/2;
			if (dp[mid] > num[i])
				e = mid;
			else
				b = mid + 1;
		}
		</span><span style="color:#ff0000;background-color: rgb(255, 204, 0);">if(dp[b]>num[i])dp[b]=num[i];
		else dp.push_back(num[i]);</span><span style="color:#222222;">
	}
	return dp.size();
}</span>

情况3，4的复杂多均为O(NlogN)，其中N体现在外层的循环上，logN是由于折半查找的复杂度。

note：

此外，还有一种动态规划的解法，计算包含节点i的子串的长度，复杂多为O(N^2)，递推公式如下

f(0)=1;

f(i)=max{f(j)|num[j]<num[i],0<=j<i}+1;