听大佬们解释，最长 上升 / 下降 子序列和最长公共子序列属线性DP范畴，由于本人还没有系统的对DP进行研究，所以这里就暂时先不阐述线性DP了。
最长 上升 / 下降 子序列和最长公共子序列这两类问题是非常典型的DP类型的题目，每一个算法学习书上面都少不了这两类问题，相关的题目也有很多，如：
导弹拦截
最长公共子序列
类似的题目还有很多，就不一 一举例了。
O（n²）解决最长上升子序列
例：由5个数组成的序列，分别为6 2 3 4 1，2 3 4就是其最长上升子序列（可能不唯一）。
以时间复杂度O（n²）解决最长上升子序列问题是最简单也是最常见的一种解法
首先，我们知道对于每个元素本身，其初始的最长上升子序列就是其本身，于是就用一个dp[i]数组表示以第i个元素为结尾时的最长上升子序列长度，所以，对于每个dp[i]，其初始长度为其本身长度，即为1。
其次，要求dp[i]数组的每一个值，O（n²）解法采取的思想是先固定一个位置 i ，然后对其前面的每一个位置进行枚举，如果前面任何一个位置 j 出现小于 i 位置的元素的情况，就要考虑是否对 i 位置的dp数组进行更新（就是考虑以 j 为结尾的最长上升子序列的长度加上i元素，也就是+1之后，是否大于此时以 i 为结尾的最长上升子序列的长度），选取最优值。
dp[i]=max(dp[i],dp[j]+1);
最后，由于dp数组的定义，只需要输出dp数组中的最大值即可。
核心代码
for(int i=2;i<=n;i++){
for(int j=1;j<i;j++){
if(a[j]<=a[i])
dp[i]=max(dp[i],dp[j]+1);
}
}
输出路径
有的题目还会让输出路径，也就是输出最长上升子序列，如果用O（n²）的解法，只需要再开一个前驱数组pre[i]，每次更新dp数组的时候跟着更新，最后迭代输出即可。
初始化时，每个元素并没有前驱，所以pre数组初始化的值为0
完整代码：
#include <iostream>
using namespace std;
int n,max_len,max_pos;
int a[100010],dp[100010],pre[100010];
void outPath(int i){
if(i==0) return;
outPath(pre[i]);
cout<<a[i]<<" ";
}
int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
}
for(int i=1;i<=n;i++){
dp[i]=1;
pre[i]=0;
}
for(int i=2;i<=n;i++){
for(int j=1;j<i;j++){
if(a[j]<=a[i] && dp[j]+1>dp[i]){
dp[i]=dp[j]+1;
pre[i]=j;
}
}
}
max_len=dp[1],max_pos=1;
for(int i=2;i<=n;i++){
if(max_len<dp[i]){
max_len=dp[i];
max_pos=i;
}
}
cout<<max_len<<endl;
outPath(max_pos);
return 0;
}
O（nlogn）解决最长上升子序列
听说树状数组也可以实现O（nlogn），但是这里并没有用到树状数组，这里用的是二分法实现O（nlogn）解决最长上升子序列。
其实很容易可以看出，对于O（n²）的做法而言，其实就是暴力枚举，把每个状态都比较遍历一遍，所以会浪费很多时间。
所以就有另外一种动态规划的方法来降低复杂度，实现O（nlogn）解决该问题。
同样定义一个dp[i]数组，数组含义为最长上升子序列长度为i时，最后一个元素的最小值，那么为什么要这么定义呢？
因为我们当前的最长上升子序列长度如果已经确定，那么如果这个长度的子序列的末尾元素越小，后面的元素就可以更方便的加入到这个我们假想的上升子序列中。
同时，由于dp数组的定义，我们也可以实现二分法了。
#include <bits/stdc++.h>
using namespace std;
int a[100005],len;
int dp[100005],m[100005];
int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
}
dp[++len]=a[1];
for(int i=2;i<=n;i++){
if(a[i]>dp[len]){ //如果a[i]大于末尾的值，则可以直接插入到序列末尾
dp[++len]=a[i];
}
else{//如果a[i]并不大于末尾的值，
//那么就去找序列中最接近a[i]的值，然后取两者的最小值赋给该子序列的末尾，
//让该长度的子序列的末尾元素尽可能的小
int left=0,right=len;
while(left<right){//就是找到序列前面最接近a[i]的数
int mid=(left+right)/2;
if(dp[mid]>a[i]){
right=mid;
}
else{
left=mid+1;
}
}
dp[left]=min(a[i],dp[left]);
//dp[left]是最接近a[i]的数，取 min(a[i],dp[left])赋给长度为left的最长子序列的末尾,
//让该长度的子序列的末尾元素尽可能的小
}
}
cout<<len;
return 0;
}
来看核心代码：
for(int i=2;i<=n;i++){
if(a[i]>dp[len]){
dp[++len]=a[i];
}
else{
int left=0,right=len;
while(left<right){
int mid=(left+right)/2;
if(dp[mid]>a[i]){
right=mid;
}
else{
left=mid+1;
}
}
dp[left]=min(a[i],dp[left]);
}
}
其实else包括的语句实现的就是让该长度的子序列的末尾元素尽可能的小，而在STL中，有两个函数可以帮我们找到需要替换掉的元素。
lower_bound会找出序列中第一个大于等于x的数
upper_bound会找出序列中第一个大于x的数
没错这俩就差个等号，如果是最小下降子序列，这两个函数也可以实现找出序列中第一个小于或小于等于x的数
int p=lower_bound(dp+1,dp+1+len,a[i])-dp;//找出序列中第一个大于等于x的数
int p=lower_bound(dp+1,dp+1+len,a[i]，greater <int> ())-dp;//找出序列中第一个小于等于x的数
//upper_bound同理
这里就不对这两个函数进行详细的解释了。
那么我们的要求是让任意长度的子序列的末尾元素尽可能的小，我们要做的就是如果a[i]不大于末尾元素，那么就找到前面序列中第一个大于a[i]的元素，然后用a[i]替换掉它。让该长度的子序列的末尾元素尽可能的小。
代码：
#include <bits/stdc++.h>
using namespace std;
int a[100005],len;
int dp[100005],m[100005];
int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++){
cin>>a[i];
}
dp[++len]=a[1];
for(int i=2;i<=n;i++){
if(a[i]>=dp[len]){
dp[++len]=a[i];
}
else{
int p=lower_bound(dp+1,dp+1+len,a[i])-dp;
dp[p]=a[i];
}
}
cout<<len;
return 0;
}
O（nlogn）能输出路径吗？好像也可以，但是会比较麻烦，这里就不讨论了。但是这也论证了一个观点：时间复杂度越高的算法越全能
O（n²）解决最长公共子序列
例：
5
3 2 1 4 5
1 2 3 4 5
则他们的最长公共子序列为3 4 5（可能不唯一）
O（n²）的思路是
设序列X={x1,x2,…,xm}和Y={y1,y2,…,yn}的最长公共子序列为Z={z1,z2,…,zk} ，则
若xm=yn，则zk=xm=yn，且zk-1是xm-1和yn-1的最长公共子序列。
若xm≠yn且zk≠xm，则Z是xm-1和Y的最长公共子序列。
若xm≠yn且zk≠yn，则Z是X和yn-1的最长公共子序列。
由最长公共子序列问题的最优子结构性质可知，要找出X和Y的最长公共子序列，可按以下方式递归地进行：
当xm＝yn时，找出Xm－1和Yn－1的最长公共子序列，然后在其尾部加上xm（yn）即可得X和Y的一个最长公共子序列。
当xm≠yn时，必须解两个子问题，即找出Xm－1和Y的一个最长公共子序列及X和Yn－1的一个最长公共子序列。这两个公共子序列中较长者为X和Y的一个最长公共子序列。
用c[i][j]记录序列和的最长公共子序列的长度。
递归关系如下
用数组b[i][j]来保存路径，最后递归输出，如果数组b为1，则说明 i 位置的x数组和 j 位置的y数组相等，输出然后递归（i-1,j-1），如果为2，则递归（i-1,j）,如果为3，则递归(i,j-1)
完整代码：
#include <bits/stdc++.h>
using namespace std;
int M[1005],N[1005],x;
int dp[1005][1005];
int b[1005][1005];
void LCS(int i,int j){
if(i==0 || j==0) return;
if(b[i][j]==1){
LCS(i-1,j-1);
cout<<M[i]<<" ";
}
else if(b[i][j]=2){
LCS(i-1,j);
}
else{
LCS(i,j-1);
}
}
int main()
{
cin>>x;
for(int i=1;i<=x;i++){
cin>>M[i];
}
for(int i=1;i<=x;i++){
cin>>N[i];
}
for(int i=1;i<=x;i++){
for(int j=1;j<=x;j++){
if(M[i]==N[j]){
dp[i][j]=dp[i-1][j-1]+1;
b[i][j]=1;
}
else if(dp[i-1][j]>=dp[i][j-1]){
dp[i][j]=dp[i-1][j];
b[i][j]=2;
}
else{
dp[i][j]=dp[i][j-1];
b[i][j]=3;
}
}
}
cout<<dp[x][x]<<endl;
LCS(x,x);
return 0;
}
O（nlogn）解决最长公共子序列
以最长公共子序列为例，因为两个序列都是1~n的全排列，那么两个序列元素互异且相同，也就是说只是位置不同罢了，那么我们通过一个m数组将A序列的数字在B序列中的位置表示出来，如果序列不是数字，可以用map进行存储
所以问题就转化为：
找出b序列每个元素在a序列中的位置的最长上升子序列
前面讲了这么多，看到这里应该不难理解，就直接上代码了。
#include <bits/stdc++.h>
using namespace std;
int M[100005],N[100005],len;
int dp[100005],m[100005];
int main()
{
int n;
cin>>n;
for(int i=1;i<=n;i++){
cin>>M[i];
m[M[i]]=i;
}
for(int i=1;i<=n;i++){
cin>>N[i];
}
dp[++len]=m[N[1]];
for(int i=2;i<=n;i++){
if(m[N[i]]>=dp[len]){
dp[++len]=m[N[i]];
}
else{
int p=lower_bound(dp+1,dp+1+len,m[N[i]])-dp;
dp[p]=m[N[i]];
}
}
cout<<len;
return 0;
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
