最长递增子串(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;