最快方法求最长上升子序列（LIS）+最长公共子序列（LCS）模板（C/C++）
目录
1 LIS算法（最长上升子序列）
1.1 简介
1.2 代码
1.3 相关解释
2 LCS算法（最长公共子序列）
2.1 简介
2.2 代码（动态规划，时间复杂度O（nlogn））
2.3 特殊情况下的优化
1 LIS算法（最长上升子序列）
1.1 简介
LIS（Longest Increasing Subsequence）最长上升子序列
一个数的序列bi，当b1 < b2 < … < bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, …, aN)，我们可以得到一些上升的子序列(ai1, ai2, …, aiK)，这里1 <= i1 < i2 < … < iK <= N。
比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4，比如子序列(1, 3, 5, 8).
你的任务，就是对于给定的序列，求出最长上升子序列的长度。
1.2 代码
#include <bits/stdc++.h>
using namespace std;
int a[99999],dp[99999]; // a数组为数据，dp[i]表示长度为i+1的LIS结尾元素的最小值
int main()
{
int n;
while(cin>>n)//**解释1**
{
for(int i=0; i<n; i++)
{
cin>>a[i];
dp[i]=INT_MAX; // 初始化为无限大
}
int pos=0; // 记录dp当前最后一位的下标
dp[0]=a[0]; // dp[0]值显然为a[0]
for(int i=1; i<n; i++)
{
if(a[i]>dp[pos]) // 若a[i]大于dp数组最大值，则直接添加
dp[++pos] = a[i];
else // 否则找到dp中第一个大于等于a[i]的位置，用a[i]替换之。
dp[lower_bound(dp,dp+pos+1,a[i])-dp]=a[i]; // 二分查找**解释2**
}
cout<<pos+1<<endl;
}
return 0;
}
1.3 相关解释
解释1：循环用例
假设我们根据给定的数字a和b，计算a与b的和。
如果使用这段代码：
#include <iostream>
using namespace std;
int main(){
int a, b;
cin >> a >> b;
cout << a + b << endl;
return 0;
}
则只能输入一组a和b，计算结束后程序就会退出。想要再计算一组和，需要重新运行程序。
如果使用循环用例：
#include <iostream>
using namespace std;
int main(){
int a, b;
while(cin >> a >> b){
cout << a + b << endl;
}
return 0;
}
则可以处理多组输入，并且返回多组输出。
解释2：二分法找第一个大于/小于某个数的函数
lower_bound( )和upper_bound( )都是利用二分查找的方法在一个排好序的数组中进行查找的。
在从小到大的排序数组中，
lower_bound( begin,end,num)：从数组的[begin,end)二分查找第一个大于或等于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。
upper_bound( begin,end,num)：从数组的[begin,end)二分查找第一个大于num的数字，找到返回该数字的地址，不存在则返回end。通过返回的地址减去起始地址begin,得到找到数字在数组中的下标。
2 LCS算法（最长公共子序列）
2.1 简介
LCS是Longest Common Subsequence的缩写，即最长公共子序列。一个序列，如果是两个或多个已知序列的子序列，且是所有子序列中最长的，则为最长公共子序列。
比如，对于char x[]="aabcd";有顺序且相互相邻的aabc是其子序列，有顺序但是不相邻的abc也是其公共子序列。即，只要得出序列中各个元素属于所给出的数列，就是子序列。
再加上char y[]="12abcabcd";对比出才可以得出最长公共子序列abcd。
2.2 代码（动态规划，时间复杂度O（n*n））
#include<bits/stdc++.h>
using namespace std;
int DP[1000][1000];
int LCS_length(string a, string b)//长度
{
int M = a.size();
int N = b.size();
for(int i=1; i<=M; i++)
{
for(int j=1; j<=N; j++)
{
if(a[i-1] == b[j-1]) DP[i][j] = DP[i-1][j-1] + 1;//最好
else if(DP[i-1][j] >= DP[i][j-1]) DP[i][j] = DP[i-1][j];
else DP[i][j] = DP[i][j-1];
}
}
return DP[M][N];
}
void LCS(string a, string b, int i, int j)//具体公共字符串
{
if(i==0 || j==0) return;//设置边界
if(a[i-1]==b[j-1])
{
LCS(a, b, i-1, j-1);
cout<<a[i-1];
}
else if(DP[i-1][j] > DP[i][j-1]) LCS(a, b, i-1, j);
else LCS(a, b, i, j-1);
}
int main()
{
string a, b;
cout<<"请输入两个字符串:"<<endl;
while(cin>>a>>b && a!="#")
{
cout<<"最大公共子序列长度为:"<<LCS_length(a, b)<<endl;
cout<<"最大公共子序列为:";
LCS(a, b, a.size(), b.size());
cout<<endl<<"请输入两个字符串:"<<endl;
}
return 0;
}
2.3 特殊情况下的优化（映射，时间复杂度O（nlogn））
特殊情况：一个序列没有重复元素，另一个序列随意
#include<bits/stdc++.h> //一个序列所有元素都不重复
using namespace std;
map <int,int> ma;
int n,m;
int s1[300009],s2[300009];
int a[300009],low[300009],len;
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)
cin>>s1[i];
for(int i=1;i<=m;i++)
cin>>s2[i];
for(int i=1;i<=m;i++)
ma[s2[i]]=i;
for(int i=1;i<=n;i++)
a[i]=ma[s1[i]];
int t=1;
while(a[t]==0) t++;
low[++len]=a[t];
for(int i=2;i<=n;i++)
{
if(a[i]==0) continue;
if(a[i]>low[len])
low[++len]=a[i];
else
{
low[upper_bound(low+1,low+len+1,a[i])-low]=a[i];//自带函数
}
}
printf("%d",len);
return 0;
}