子序列问题：LIS与LCS (21.10.19)

于 2021-10-19 01:38:56 发布
阅读量236 收藏 1
点赞数 3
分类专栏： ACM学习笔记 文章标签： 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51443397/article/details/120838241
版权

前题引入戳一戳
有关最长上升子序列问题，从前只会用动态规划解决，直到看了P1020 导弹拦截这个题才知道还有更省时更巧妙的方法，也拓一拓思路，搜索了一些资料了解了LIS和LCS，下面做个简单总结。

子序列问题

一、LIS

1.概念

•LIS即最长上升子序列。对于固定的数组，LIS序列不一定是唯一的，但LIS的长度一定是唯一的。
例如：序列｛2，4，3，7，9｝
LIS序列可以是｛2，4，7，9｝或｛2，3，7，9｝，长度都为4。

•求LIS的三种方法：O(n2)的DP，O(nlogn)的二分+贪心法，O(nlogn)的树状数组优化的DP。

2.方法

动态规划 O(n2)

这里先明确一下子序列的概念，简单地说子序列不一定连续但在原序列里的前后顺序不可变。再说这个题的思路，每个状态可以理解为以每个位置为终点的最长上升子序列。这里需要通过双重循环实现，外循环记录终点位置，内循环记录终点前的点，利用一个一维数组记录终点位置子序列的最大长度和一个变量记录终点前点递增位置的子序列长度。
简单说就是如果以当前点为终点，找之前小于当前位置的点的最大子序列，在此基础上加1作为当前点的最大子序列。这只是一种情况，还需结合每一个位置为终点的情况再求出一个最终解。
详细回顾
最长上升子序列模板：

#include<iostream>
#include<cstdio>
using namespace std;
int a[1005],b[1005];//b[i]表示以第i个数为终点的最长上升子序列的长度
int main()
{
    int x,n=1,sum=0;
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    for(int i=1;i<=n;i++)
    {
        b[i]=1;
        for(int j=1;j<i;j++)
        {
            if(a[j]<a[i])
                b[i]=max(b[i],b[j]+1);
        }
        sum=max(sum,b[i]);
    }
    printf("%d",sum);
}

二分+贪心 O(nlogn)

假设我们构建一个数组a[]存最长上升子序列，len表示a的最大下标。当我们从头扫描已知序列时，遇到一个数比a[len]大时，直接把它加到a[len]后面即可，即a[len++]，但如果比a[len]小或者相等时，本应跳过，这里考虑两种情况，设当前扫描到已知序列的数为y：
•如果a[len-1]<y<a[len]，根据贪心思想，肯定是序列a的末尾数越小越好，这样后面就可以接更多数。所以用y替换当前的a[len]，即a[len]=y。
•如果y<…<a[len-1]<a[len]，此时并不影响序列以后的连接。
以上两种情况怎么实现呢？对于情况1，我们可以理解为找数组a中第一个大于等于y的下标k，情况1是k=len，然后替换a[k]=y，这时你就会发现该做法代到情况2里也成立 ，因为序列a的末尾根本没受影响。
但为啥要找第一个大于等于x的数，找第一个大于x的数不行吗？
举个例子：

原始序列为{9,7,3,3,5,4,2}
当扫描到9时，{9}
当扫描到7时，{7}
当扫描到3时，{3}
当扫描到3时，此时最长上升子序列里找不到第一个大于3的数，所以应该找第一个大于等于3的数，确保替换成功。

下面有两种方法找第一个大于等于y的数:
法1：自己写二分查找函数：二分回顾
模板：

#include<iostream>
#include<functional>
#include<algorithm>
#include<cstring>
using namespace std;
int a[100005],b[100005];
int n=0,len=0;
int Find(int m)
{
    int l=0,r=len;//数组存数的最大下标
    while(l<r)
    {
        int mid=l+r>>1;
        if(m<=b[mid]) r=mid;
        else l=mid+1;
    }
    return l;
}
int main( )
{
    cin>>n;
    for(int i=0; i<n; i++)
        cin>>a[i];
    b[0]=a[0];
    for(int i=1; i<n; i++)
    {
        if(b[len]<a[i])
        {
            b[++len]=a[i];
        }
        else
        {
            b[Find(a[i])]=a[i];
        }
    }
    cout<<len+1<<endl;
}

法2：
在这里插入图片描述
lower_bound会找出序列中第一个大于等于x的数
upper_bound会找出序列中第一个大于x的数
lower_bound与upper_bound都是在序列已经相对递增有序的基础上实现的
我们可以让k=lower_bound(b,b+len,a[i])-b，k即为所要替换的下标。
模板：

#include<iostream>
#include<functional>
#include<algorithm>
#include<cstring>
using namespace std;
int a[100005],b[100005];
int main( )
{
    int n,len=0;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i];
    b[0]=a[0];
    for(int i=1; i<n; i++)
    {
        if(b[len]<a[i])
        {
            b[++len]=a[i];
        }
        else
        {
            int k=lower_bound(b,b+len,a[i])-b;
            b[k]=a[i];
        }
    }
    cout<<len+1<<endl;
}

树状数组优化的DP O(nlogn)

树状数组回顾
数状数组优化的DP的参考来源
把a[]从小到大排序，同时把a[i]在排序之前的序号记录下来，然后从小到大枚举a[i]，每次用编号小于等于a[ i ]编号的元素的LIS长度+1来更新答案，同时把编号大于等于a[ i ]编号元素的LIS长度+1。因为a数组已经是有序的，所以可以直接更新。
注意：树状数组求LIS不去重的话就变成了最长不下降子序列了。
树状数组 1. 求前缀最大值， 2.单点修改(往大里改)

#include<iostream>
#include<math.h>
#include<algorithm>
#include<cstdio>
#define lowbit(x) ((x)&-(x))
using namespace std;
const int INF=0x7f7f7f7f;
struct Node
{
    int val,num;
} a[100005];
int n,b[100005];
bool cmp(Node a,Node b)
{
    return a.val==b.val?a.num<b.num:a.val<b.val;
}
void modify(int x,int y)//把b[x]替换为b[x]和y中较大的数
{
    while(x<=n)
    {
        b[x]=max(b[x],y);
        x+=lowbit(x);
    }
}
int query(int x)//返回b[1]~b[x]中的最大值
{
    int res=-INF;
    while(x)
    {
        res=max(res,b[x]);
        x-=lowbit(x);
    }
    return res;
}
int main( )
{
    int ans=0;
    scanf("%d",&n);
    for(int i=1; i<=n; i++)
    {
        scanf("%d",&a[i].val);
        a[i].num=i;//记住编号，有点类似于离散化的处理，但没有去重
    }
    sort(a+1,a+n+1,cmp);//以权值为第一关键字从小到大排序
    for(int i=1; i<=n; i++) //按权值从小到大枚举
    {
        int maxx=query(a[i].num);//查询编号小于等于num的LIS最大长度
        modify(a[i].num,++maxx);//把长度+1，再去更新前面的LIS长度
        ans=max(ans,maxx);//更新答案
    }
    printf("%d\n",ans);
}

3.推广

最长下降子序列

O(n2)动态规划：

#include<iostream>
#include<cstdio>
using namespace std;
int a[1005],b[1005];//b[i]表示以第i个数为终点的最长下降子序列的长度
int main()
{
    int x,n=1,sum=0;
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    for(int i=1;i<=n;i++)
    {
        b[i]=1;
        for(int j=1;j<i;j++)
        {
            if(a[j]>a[i])
                b[i]=max(b[i],b[j]+1);
        }
        sum=max(sum,b[i]);
    }
    printf("%d",sum);
}

O(nlogn)二分+贪心：

#include<iostream>
#include<functional>
#include<algorithm>
#include<cstring>
using namespace std;
int a[100005],b[100005];
int main( )
{
    int n,len=0;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>a[i];
    b[0]=a[0];
    for(int i=1; i<n; i++)
    {
        if(b[len]>a[i])
        {
            b[++len]=a[i];
        }
        else
        {
            int k=lower_bound(b,b+len,a[i],greater<int>())-b;
            b[k]=a[i];
        }
    }
    cout<<len+1<<endl;
}

或

#include<iostream>
#include<functional>
#include<algorithm>
#include<cstring>
using namespace std;
int a[100005],b[100005];
int n=0,len=0;
int Find(int m)
{
    int l=0,r=len;//数组存数的最大下标
    while(l<r)
    {
        int mid=l+r>>1;
        if(m>=b[mid]) r=mid;
        else l=mid+1;
    }
    return l;
}
int main( )
{
    cin>>n;
    for(int i=0; i<n; i++)
        cin>>a[i];
    b[0]=a[0];
    for(int i=1; i<n; i++)
    {
        if(b[len]>a[i])
        {
            b[++len]=a[i];
        }
        else
        {
            b[Find(a[i])]=a[i];
        }
    }
    cout<<len+1<<endl;
}

最长不下降子序列

O(n2)动态规划：

#include<iostream>
#include<cstdio>
using namespace std;
int a[1005],b[1005];//b[i]表示以第i个数为终点的最长不下降子序列的长度
int main()
{
    int x,n=1,sum=0;
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    for(int i=1;i<=n;i++)
    {
        b[i]=1;
        for(int j=1;j<i;j++)
        {
            if(a[j]<=a[i])
                b[i]=max(b[i],b[j]+1);
        }
        sum=max(sum,b[i]);
    }
    printf("%d",sum);
}

O(nlogn)二分+贪心：

#include<iostream>
#include<functional>
#include<algorithm>
#include<cstring>
using namespace std;
int a[100005],b[100005];
int main( )
{
    int n=0,sum=0,x;
    while(cin>>x)
    {
        a[n++]=x;
    }
    b[0]=a[0];
    for(int i=1; i<n; i++)
    {
        if(b[sum]<=a[i])
        {
            b[++sum]=a[i];
        }
        else
        {
            int t=upper_bound(b,b+sum,a[i],greater<int>())-b;
            b[t]=a[i];
        }
    }
    cout<<sum+1<<endl;
}

或

#include<iostream>
#include<functional>
#include<algorithm>
#include<cstring>
using namespace std;
int a[100005],b[100005];
int n=0,len=0;
int Find(int m)
{
    int l=0,r=len;//数组存数的最大下标
    while(l<r)
    {
        int mid=l+r>>1;
        if(m<b[mid]) r=mid;
        else l=mid+1;
    }
    return l;
}
int main( )
{
    cin>>n;
    for(int i=0; i<n; i++)
        cin>>a[i];
    b[0]=a[0];
    for(int i=1; i<n; i++)
    {
        if(b[len]<=a[i])
        {
            b[++len]=a[i];
        }
        else
        {
            b[Find(a[i])]=a[i];
        }
    }
    cout<<len+1<<endl;
}

最长不上升子序列

O(n2)动态规划：

#include<iostream>
#include<cstdio>
using namespace std;
int a[1005],b[1005];//b[i]表示以第i个数为终点的最长不上升子序列的长度
int main()
{
    int x,n=1,sum=0;
    int n;
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>a[i];
    for(int i=1;i<=n;i++)
    {
        b[i]=1;
        for(int j=1;j<i;j++)
        {
            if(a[j]>=a[i])
                b[i]=max(b[i],b[j]+1);
        }
        sum=max(sum,b[i]);
    }
    printf("%d",sum);
}

O(nlogn)二分+贪心：

#include<iostream>
#include<functional>
#include<algorithm>
#include<cstring>
using namespace std;
int a[100005],b[100005];
int main( )
{
    int n=0,sum=0,x;
    while(cin>>x)
    {
        a[n++]=x;
    }
    b[0]=a[0];
    for(int i=1; i<n; i++)
    {
        if(b[sum]>=a[i])
        {
            b[++sum]=a[i];
        }
        else
        {
            int t=upper_bound(b,b+sum,a[i],greater<int>())-b;
            b[t]=a[i];
        }
    }
    cout<<sum+1<<endl;
}

或

#include<iostream>
#include<functional>
#include<algorithm>
#include<cstring>
using namespace std;
int a[100005],b[100005];
int n=0,len=0;
int Find(int m)
{
    int l=0,r=len;//数组存数的最大下标
    while(l<r)
    {
        int mid=l+r>>1;
        if(m>b[mid]) r=mid;
        else l=mid+1;
    }
    return l;
}
int main( )
{
    cin>>n;
    for(int i=0; i<n; i++)
        cin>>a[i];
    b[0]=a[0];
    for(int i=1; i<n; i++)
    {
        if(b[len]>=a[i])
        {
            b[++len]=a[i];
        }
        else
        {
            b[Find(a[i])]=a[i];
        }
    }
    cout<<len+1<<endl;
}

小总结
最长上升子序列和最长下降子序列都用lower_bound()函数
最长不上升子序列和最长不下降子序列都用upper_bound()函数

二、LCS

1.概念

·公共子序列：如果Z既是X的子序列，又是Y的子序列，则称Z为X和Y的公共子序列
·LCS就是最长公共子序列。

2.方法

动态规划

要抽象出一个二维数组，这个二维数组的第0行和第0列我们不用，让它默认为0，从第一行和列开始，行代表A串的每个字符位置，列代表B串的每个字符位置。这里需要用到双重循环实现，大循环循环A，小循环寻找B的每个位置与A的公共子序列，如果B的某位置与A当前位置字符相同，就在前一个公共子序列的基础上加一，如果不同，就找前一步最大的当做当前位置的值
状态转移方程：
当i=0或j=0时：DP[i][j]=0
当A[i] == B[j] 时 ：DP[i][j] = DP[i-1][j-1] + 1
当A[i] != B[j] 时 ： DP[i][j] = MAX(DP[i-1][j] , DP[i][j-1])

#include <iostream>
#include <cstdio>
#include <cstring>
#define MAX 1000
int dp[MAX+1][MAX+1];
char s[MAX],t[MAX];
int max(int a,int b)
{return a>b?a:b;}
int main()
{
	int N,i,j,n,m;
	scanf("%d",&N);
	while(N--)
	{
		scanf("%s%s",s,t);
		int x=strlen(s),y=strlen(t);
		for(i=0;i<x;i++)
		{
			for(j=0;j<y;j++)
 
				if(s[i]==t[j])
					dp[i+1][j+1]=dp[i][j]+1;
				else
					dp[i+1][j+1]=max(dp[i+1][j],dp[i][j+1]);
		}
		printf("%d\n",dp[i][j]);			
	}
	return 0;
}
未定_
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LIS & LCS（动态规划)
01-20
问题描述 东东有两个序列A和B。 他想要知道序列A的LIS和序列AB的LCS的长度。 注意，LIS为严格递增的，即a1<a2<…<ak(ai<=1,000,000,000)。 Input 第一行两个数n，m（1<=n<=5,000,1<=m<=5,000） 第二行n个数，表示序列A 第三行m个数，表示序列B Output 输出一行数据ans1和ans2，分别代表序列A的LIS和序列AB的LCS的长度 解题思路 这个题是基本的动态规划问题，LIS是最长上升子序列，LCS是最长公共子序列。 求解LIS就是设dp[i]为以当前元素结尾的最长上升序列，那么dp[i]=max(dp[j]∣j<i&&a[
LIS 最长递增子序列 Java的简单实现
09-01
最长递增子序列（Longest Increasing Subsequence, LIS）是计算机科学中的一种经典问题，它在数组或序列中寻找一个尽可能长的递增子序列。这个问题具有多种应用，如在股票交易策略、优化调度和生物信息学等领域都...
LIS LCS LCIS （主要过一遍，重在做题）
weixin_30469895的博客
04-19 152
只详细讲解LCS和LCIS，别的不讲…做题优先。 菜鸟能力有限写不了题解，可以留评论，我给你找博客。 先得理解最长上升子序列吧，那个HDOJ拦截导弹系列可以做一下，然后用o(n)log(n)的在做一遍 然后就是真正理解LCS； 真正理解源于做题，做题就像查漏补缺一样，你总有不会的地方。 【完全的求一个最长公共子序列】 (非常彻底地理解路径或者说是状态转移的规律)...
LCS LIS
Ansoer
08-10 303
最长上升子序列 （LIS，Longest Increasing Subsequence）：      给定一个长度为 n 的数列 a0,a1,a2,...an-1，求该数列中的最长上升子序列。     核心代码一：（两层for循环实现  O(n ^ 2)） int n; int a[MAXN], dp[MAXN]; scanf("%d", &amp;n); for(int i = 0; i...
LIS LCS(模板)
北里五井的博客
04-11 174
LIS：最长上升子序列（Longest Increasing Subsequence），给定n个整数，A1，A2....An,按从左到右的顺序选出尽量多的整数，组成一个上升子序列（子序列:删除0个或多个数，其他数的顺序不变）。时间复杂度:O(n^2)#include&lt;iostream&gt; #include&lt;algorithm&gt; using namespace std; int...
LIS和LCS
Jiangislogining的博客
10-23 497
最长上升子序列，最长公共子序列，最长公共子串
C语言实现最长递增子序列问题的解决方法
09-04
最长递增子序列（Longest Increasing Subsequence, LIS）问题是计算机科学中的一种经典算法问题，主要涉及序列处理和动态规划。在给定的序列中，目标是找到一个尽可能长的子序列，使得这个子序列中的元素是严格递增...
最长递增子序列 动态规划法.cpp.rar
10-14
在最长递增子序列问题上，我们可以使用一个数组dp来存储到当前位置i为止的最长递增子序列的长度。 以下是动态规划解决最长递增子序列的步骤： 1. 初始化：创建一个长度为n（数组长度）的dp数组，所有元素都初始...
lis2dh12.rar
07-03
iic通讯代码 lis2dh12底层驱动代码 读取加速度值 分层清晰
Jispy：lis.py的直接翻译
02-17
标题 "Jispy：lis.py的直接翻译" 暗示了这是一个关于将Python代码转换为Java语言的项目，特别是针对一个名为`lis.py`的Python脚本。在这个项目中，`Jispy`可能是作者为Java版本的Python代码起的新名称或者是一个工具...
LCS、LIS
MH3709的博客
05-23 464
LCS是最长公共子序列的表示： 题目链接 代码也十分简单就不敲了。 LIS是最长上升子序列的英文缩写。 (动态规划) O(n2)O(n2) 状态表示：f[i]表示从第一个数字开始算，以w[i]结尾的最大的上升序列。(以w[i]结尾的所有上升序列中属性为最大值的那一个) 状态计算（集合划分）：j∈(0,1,2,…,i-1), 在w[i] > w[j]时， f[i] = max(f[i], f[j] + 1)。 有一个边界，若前面没有比i小的，f[i]为1（自己为结尾）。 最后在找f[i]的最大值。 时
8.9 LIS，LCS
不甘
08-09 163
最长公共子序列 LCS（白书P56） （The longest common subsequence，LCS） 一个数列 ，如果分别是两个或多个已知数列的子序列，且是所有符合此条件序列中最长的，则 称为已知序列的最长公共子序列。 最长公共子串 最长公共子串要求在原字符串中是连续的 最长上升子序列（白书P64） (Longest Increasing Subsequence，LIS)，在...
LIS && LCS
weixin_43578672的博客
06-07 153
LIS，LCS是动态规划的经典例题。 LIS——最长上升子序列 给定n 个整数Ai, A2,…, An，按从左到右的顺序选出尽量多的整数，组成一个上升子序列。 要求输出最长上升子序列的长度。 例如，序列1,6,2,3,7,5  上升子序列可以是1,6,2,3,7,5 ；也可以是1,6,2,3,7,5  最长上升子序列为1,2,3,5，其长度为4，故ans= 4 如果要输出最长上升子序列的索引，可以用pre数组记录前驱 例题-某个周参加的ACM校赛–送礼物 题目描述 XY想给喜欢的女生送礼物，但自从上次圣
【动态规划】LIS LCS
lx233
08-22 250
  参考网站（不） 题目描述  一个数列ai如果满足条件a1 &lt; a2 &lt; ... &lt; aN，那么它是一个有序的上升数列。我们取数列(a1, a2, ..., aN)的任一子序列(ai1, ai2, ..., aiK)使得1 &lt;= i1 &lt; i2 &lt; ... &lt; iK &lt;= N。例如，数列(1, 7, 3, 5, 9, 4, 8)的有序上升子序...
LCS和LIS
qq_45833256的博客
03-18 224
LCS（最长公共子序列） 模板题： http://acm.hdu.edu.cn/showproblem.php?pid=1159 Common Subsequence（最长公共子序列） 题意： 求两端字符串的最长公共子序列的长度 通过二维数组保存每段LCS的长度，则状态转移方程为： 实现过程： 以s1={1,3,4,5,6,7,7,8},s2={3,5,7,4,8,6,7,8,2}为例。 c[i,j]的定义，记录的LCS的长度值。 通过递归公式填入表中，如果横竖（i,j）对应的两个元素相等，该格子的值
B - LIS & LCS
weixin_44934885的博客
04-24 225
题意介绍 给两个序列，求第一个序列的LIS长度和两个序列的LCS长度 题意分析 最长上升子序列 状态：定义 fi 表示以 Ai 为结尾的最长上升序列的方程。 初始化：f1 = 1 转移过程 输出答案：max{f[i], i=1…n} 最长公共子序列 设计状态：假设 f[i][j] 为 A1, A2, …, Ai 和 B1, B2, …, Bj 的 LCS 长度 初始化：初始 f[1][0] = f...
LIS 和LCS模版
寂寞风中一匹狼的博客
03-29 157
//最长上升子序列 int dp[MAX_N],a[MAX_N],n,ans=0;for(int i = 1;i &lt;= n;i++){ dp[i]=1; for(int j = 1;j &lt; i;j++){ if(a[j]&lt;a[i]){ dp[i]=max(dp[i],dp[j]+1); } } ans=max(ans,dp[i]);}//最长公共子序列char s1[MA...
Week10：LIS与LCS
qq_44506233的博客
05-05 183
概念引入 LIS（最长上升子序列）：对于某个长为n的数列a0, a1, …, a(n-1)，其上升子序列指的是对于任意的i<j都满足ai<aj的子序列。最长上升子序列即为这些子序列里最长的那个。 LCS（最长公共子序列）：对于两个数列s1,s2，s1和s2的相同子序列，且该子序列的长度最长，即是LCS。 子序列是什么？如下图： 题目描述 给出两个序列A,B，要求得出A的LIS的长度与...
with open('2019Charity.csv', 'r', encoding='utf-8') as f: lis = [i.strip().split(',') for i in f.readlines()] pro = [] for i in lis: if i[3] not in pro: pro.append(i[3]) n = input() if n.lower() == 'total': num = sum([eval(i[5]) for i in lis[1:]]) print(f'Total:{num}万元') elif n in [str(i) for i in range(1, 101)]: for i in lis[1:]: if eval(i[0]) == eval(n): print(' '.join(i)) elif n in pro: for i in lis: if n in i: print(' '.join(i[:4])) else: print('No Record')修改代码
最新发布
06-07
如果用户输入的是 1-100 中的数字，则程序将查找对应的项目编号并打印与该编号对应的记录。如果用户输入的是一个省份名称，则程序将查找该省份的所有记录并打印相关信息。如果用户输入的不是这些选项，则程序将打印 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值