最长上升子序列模型与题目详解acm

最新推荐文章于 2024-01-18 16:25:43 发布
最新推荐文章于 2024-01-18 16:25:43 发布
阅读量362 收藏 3
点赞数 1
分类专栏： 算法模板 文章标签： 算法 acm lis 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lafea/article/details/108368616
版权

LIS问题

acwing题库
在这里插入图片描述

##最长上升子序列

https://www.acwing.com/problem/content/897/
在这里插入图片描述

----c++版

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

const int N=1010;

int n;
int a[N],f[N];

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(int i=1;i<=n;i++){
        f[i]=1;//只有a[i]一个数
        for(int j=1;j<i;j++)
            if(a[j]<a[i])
                f[i]=max(f[i],f[j]+1);
    }
    int res=0;
    for(int i=1;i<=n;i++)res=max(res,f[i]);
    printf("%d", res);
    return 0;
}

输出具体子序列

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

const int N=1010;

int n;
int a[N],f[N],g[N];

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(int i=1;i<=n;i++){
        f[i]=1;//只有a[i]一个数
        g[i]=0;
        for(int j=1;j<i;j++)
            if(a[j]<a[i])
                if(f[i]<f[j]+1){
                    f[i]=f[j]+1;
                    g[i]=j;
                }
    }
    int k=1;
    for(int i=1;i<=n;i++)
        if(f[k]<f[i])
            k=i;

    printf("%d\n", f[k]);
    for(int i=0,len=f[k];i<len;i++){
        printf("%d ",a[k]);
        k=g[k];
    }
    
    return 0;
}

##最长上升子序列2

https://www.acwing.com/problem/content/898/

----c++版

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

const int N=1e5+100; 

int n;
int a[N];
int q[N];//存以下标为长度的上升子序列的最后一个数

int main(){
    scanf("%d", &n);
    for(int i=0;i<n;i++)scanf("%d",&a[i]);
    
    int len=0;
    q[0]=-2e9;//保证小于某个数的数一定存在
    for(int i=0;i<n;i++){
        int l=0,r=len;//巧妙的二分
        while(l<r){
            int mid=l+r+1>>1;
            if(q[mid]<a[i])l=mid;
            else r=mid-1;
        }
        len=max(len,r+1);
        q[r+1]=a[i];
    }
    printf("%d",len);
    return 0;
}

##最长公共子序列

https://www.acwing.com/problem/content/899/
在这里插入图片描述

----c++版

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

const int N=1010;

int n,m;
char a[N],b[N];
int f[N][N];

int main(){
    scanf("%d%d",&n,&m);
    scanf("%s%s",a+1,b+1);
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            f[i][j]=max(f[i-1][j],f[i][j-1]);
            if(a[i]==b[j])f[i][j]=max(f[i][j],f[i-1][j-1]+1);
        }
    printf("%d", f[n][m]);
    return 0;
}

##怪盗基德的滑翔翼

https://www.acwing.com/problem/content/1019/

----c++版

#include<iostream>
#include<algorithm>
using namespace std;
//转化为双向的lis问题
const int N=110;
int n;
int a[N],f[N];

int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        for(int i=1;i<=n;i++)scanf("%d",&a[i]);
        
        //正向求解lis问题
        int res=0;
        for(int i=1;i<=n;i++){
            f[i]=1;
            for(int j=1;j<i;j++)
                if(a[i]>a[j])
                    f[i]=max(f[i], f[j]+1);
            res=max(res,f[i]);
        }
        //由于是全局最小值，res不需要做变化
        //反向求解
        for(int i=n;i;i--){
            f[i]=1;
            for(int j=n;j>i;j--)
                if(a[i]>a[j])
                    f[i]=max(f[i],f[j]+1);
            res=max(res,f[i]);
        }
        printf("%d\n",res);
    }
    
    return 0;
}

##登山

https://www.acwing.com/problem/content/1016/

在这里插入图片描述

----c++版

#include<iostream>
#include<algorithm>
using namespace std;
//又以1017怪盗基德的滑翔翼为基础进一步的拓展
//集合可以按中间最高峰a[i]划分
const int N=1010;
int n;
int a[N];
int f[N],g[N];

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(int i=1;i<=n;i++){
        f[i]=1;
        for(int j=1;j<i;j++)
            if(a[i]>a[j])
                f[i]=max(f[i],f[j]+1);
    }
    
    for(int i=n;i;i--){
        g[i]=1;
        for(int j=n;j>i;j--)
            if(a[i]>a[j])
                g[i]=max(g[i],g[j]+1);
    }
    
    int res=0;
    for(int i=1;i<=n;i++)res=max(res, f[i]+g[i]-1);
    printf("%d",res);
    return 0;
}

##合唱队形


https://www.acwing.com/problem/content/484/

----c++版

#include<iostream>
#include<algorithm>
using namespace std;
//和登山一模一样
const int N=110;
int n;
int a[N];
int f[N],g[N];

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(int i=1;i<=n;i++){
        f[i]=1;
        for(int j=1;j<i;j++)
            if(a[i]>a[j])
                f[i]=max(f[i],f[j]+1);
    }
    
    for(int i=n;i;i--){
        g[i]=1;
        for(int j=n;j>i;j--)
            if(a[i]>a[j])
                g[i]=max(g[i],g[j]+1);
    }
    
    int res=0;
    for(int i=1;i<=n;i++)res=max(res, f[i]+g[i]-1);
    printf("%d",n-res);//就变了这里
    return 0;
}

##友好城市

https://www.acwing.com/problem/content/1014/

在这里插入图片描述

----c++版

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

typedef pair<int, int>pll;
const int N=5010;
int n;
pll q[N];
int f[N];
int main(){
    scanf("%d",&n);
    for(int i=0;i<n;i++)scanf("%d%d",&q[i].first,&q[i].second);
    sort(q,q+n);//相当于给了一个新下标first，下标存的值是second
    //变为lis问题，second的值不能交叉，也就是要最长上升子序列
    int res=0;
    for(int i=0;i<n;i++){
        f[i]=1;
        for(int j=0;j<i;j++)
            if(q[i].second>q[j].second)
                f[i]=max(f[i],f[j]+1);
        res=max(res,f[i]);
    }
    printf("%d",res);
    return 0;
}

##最大上升子序列和

https://www.acwing.com/problem/content/1018/

----c++版

#include<iostream>
#include<algorithm>
using namespace std;
//集合：所有以a[i]结尾的上升子序列
//属性：每一个子序列和的最大值
//状态计算：如下
const int N=1010;
int n;
int a[N],f[N];

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(int i=1;i<=n;i++){
        f[i]=a[i];
        for(int j=1;j<=i;j++)
            if(a[j]<a[i])
                f[i]=max(f[i], f[j]+a[i]);
    }
    int res=0;
    for(int i=1;i<=n;i++)res=max(res, f[i]);
    printf("%d",res);
    return 0;
}

##拦截导弹

https://www.acwing.com/problem/content/1012/

----c++版

#include<iostream>
#include<algorithm>
using namespace std;
//第一问：最长不上升子序列
//第二问：采用贪心的思路
//        从前到后遍历每一项
//        选择1：接在现有的某个子序列之后/放在结尾大于等于它的最小子序列后面
//        选择2：创建一个新系统/所有子序列结尾都小于当前数
//        争取让剩下子序列结尾的数尽可能大

//证明：由当前操作可以得到一组可行解，ans<=cnt
//      假设最优解对应方案和当前方案不同，则我们可以找到第一个数，其接在结尾大于等于它的非最小子序列后
//      我们可以将其调整到结尾大于等于它的最小子序列后面，
//      且没有增加序列的个数，接着重复此步骤，我们可以将最优解调整成当前方案解，调整的次数是有限的
//      可以认为cnt<=ans, 得证
//我们可以惊奇的发现，这个答案和求最长上升子序列的贪心过程一样，答案也一样
//着这两个问题是对偶问题
//反链定理                                                             dilworth定理
#include<sstream>
const int N=1010;
int n;
int h[N],f[N],g[N];
int main(){
    string line;
    getline(cin, line);
    stringstream ssin(line);
    while(ssin>>h[n])n++;
    
    int res=0,cnt=0;
    for(int i=0;i<n;i++){
        f[i]=1;
        for(int j=0;j<i;j++)
            if(h[i]<=h[j])
                f[i]=max(f[i], f[j]+1);
        res=max(res,f[i]);
    }
    cout<<res<<endl;
    for(int i=0;i<n;i++){
        int k=0;
        while(k<cnt&&g[k]<h[i])k++;
        g[k]=h[i];
        if(k>=cnt)cnt++;
    }
    cout<<cnt<<endl;
    
    return 0;
}

##导弹防御系统

https://www.acwing.com/problem/content/189/

----c++版

#include<iostream>
#include<algorithm>
using namespace std;
//爆搜
const int N=55;
int n;
int q[N];
int up[N],down[N];
int ans;

void dfs(int u,int su, int sd){
    if(su+sd>=ans)return;
    if(u==n){
        ans=su+sd;
        return;
    }
    //将当前数放到上升子序列中
    int k=0;
    while(k<su&&up[k]>=q[u])k++;//找到一个结尾小于当前数的最小子序列
    int t=up[k];//备份一下当前末尾的，方便恢复
    up[k]=q[u];
    if(k<su)dfs(u+1, su, sd);//不开新组
    else dfs(u+1, su+1, sd);
    up[k]=t;
    //将当前数放入下降子序列中
    k=0;
    while(k<sd&&down[k]<=q[u])k++;
    t=down[k];
    down[k]=q[u];
    if(k<sd)dfs(u+1, su, sd);
    else dfs(u+1, su, sd+1);
    down[k]=t;
}
int main(){
    while(cin>>n, n){
        for(int i=0;i<n;i++)cin>>q[i];
        ans=n;
        dfs(0,0,0);
        cout<<ans<<endl;
    }
    return 0;
}

##最长公共上升子序列

https://www.acwing.com/problem/content/274/
在这里插入图片描述

----c++版

#include<iostream>
#include<algorithm>
using namespace std;
//集合：f[i,j]所有由第一个序列的前i个字母，第二个人序列的前j个字母构成，且以b[j]结尾的公共上升子序列
//属性：max
//计算：
const int N=3010;
int n;
int a[N],b[N];
int f[N][N];

int main(){
    scanf("%d", &n);
    for(int i=1;i<=n;i++)scanf("%d", &a[i]);
    for(int j=1;j<=n;j++)scanf("%d", &b[j]);
    
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++){
            f[i][j]=f[i-1][j];//先等于右半边
            if(a[i]==b[j]){
                f[i][j]=1;
                for(int k=1;k<j;k++)
                    if(b[k]<b[j])
                        f[i][j]=max(f[i][j], f[i][k]+1);
            }
        }
    int res=0;
    for(int i=1;i<=n;i++)res=max(res, f[n][i]);
    printf("%d", res);
    return 0;
}

优化掉一层循环

#include<iostream>
#include<algorithm>
using namespace std;
//集合：f[i,j]所有由第一个序列的前i个字母，第二个人序列的前j个字母构成，且以b[j]结尾的公共上升子序列
//属性：max
//计算：
const int N=3010;
int n;
int a[N],b[N];
int f[N][N];
int g[N][N];
int main(){
    scanf("%d", &n);
    for(int i=1;i<=n;i++)scanf("%d", &a[i]);
    for(int j=1;j<=n;j++)scanf("%d", &b[j]);
    
    for(int i=1;i<=n;i++){
        g[i][0]=1;
        for(int j=1;j<=n;j++){
            f[i][j]=f[i-1][j];//先等于右半边
            if(a[i]==b[j])f[i][j]=max(f[i][j], g[i][j-1]);
            g[i][j]=g[i][j-1];
            if(a[i]>b[j])g[i][j]=max(g[i][j], f[i][j]+1);
        }
    }
    int res=0;
    for(int i=1;i<=n;i++)res=max(res, f[n][i]);
    printf("%d", res);
    return 0;
}

不超记忆的内存

#include<iostream>
#include<algorithm>
using namespace std;
//集合：f[i,j]所有由第一个序列的前i个字母，第二个人序列的前j个字母构成，且以b[j]结尾的公共上升子序列
//属性：max
//计算：
const int N=3010;
int n;
int a[N],b[N];
int f[N][N];

int main(){
    scanf("%d", &n);
    for(int i=1;i<=n;i++)scanf("%d", &a[i]);
    for(int j=1;j<=n;j++)scanf("%d", &b[j]);
    
    for(int i=1;i<=n;i++){
        int maxv=1;
        for(int j=1;j<=n;j++){
            f[i][j]=f[i-1][j];//先等于右半边
            if(a[i]==b[j])f[i][j]=max(f[i][j], maxv);
            if(a[i]>b[j])maxv=max(maxv, f[i][j]+1);
        }
    }
    int res=0;
    for(int i=1;i<=n;i++)res=max(res, f[n][i]);
    printf("%d", res);
    return 0;
}
你哥同学
关注
专栏目录
《英雄编程体验课》第 15 课 | C语言中的数学库
英雄哪里出来
07-05 5万+
C语言中的数学库
最长上升子序列题目大合集
Good good study Day day up~\(≧▽≦)/~
11-11 3954
先看看第一题，再由点到面地延伸： 1759:最长上升子序列 描述 一个数的序列bi，当b1 b2 bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 i1 i2 iK  你的任务，就是对于给定的序列，求出最长上升子序列的长度。 输入
最长上升子序列
代码改变世界，keep coding。
04-22 1403
点击打开链接 最长上升子序列 Time Limit: 3000MS Memory limit: 65536K 题目描述 一个数的序列bi，当b1 2 S的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里11 < i2 K
最长上升子序列（LIS）题目合集
weixin_34416754的博客
04-08 187
有关最长上升子序列的详细算法解释在http://www.cnblogs.com/denghaiquan/p/6679952.html 1）51nod 1134 　　一题裸的最长上升子序列，由于N<=50000，n2算法会超时，只能用nlogn算法。 　 1 #include <iostream> 2 #include <cstdio> ...
动态规划-最长上升子序列
haibao637的专栏
03-07 384
动态规划：保存递归中间结果，减少递归次数 总时间限制: 2000ms 内存限制: 65536kB 描述一个数的序列bi，当b1 b2 bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 i1 i2 iK  你的任务，就是对于给定的序列，求出最长上升子序列
关于最长上升子序列问题的题目合集（动态规划、贪心、二分优化）
IT__God的博客
08-26 293
关于最大上升子序列问题的子问题，涉及二分贪心优化
ACM竞赛介绍和题目类型介绍.pdf
04-24
动态规划题目通常涉及最优化问题，如背包问题、最长公共子序列等。参赛者需要设计合适的动态规划算法，通过递归关系式和状态转移方程来解决问题。 ##### 3.5 几何问题 几何问题要求参赛者能够处理二维或三维空间中...
ACM 2006 题目
10-21
《ACM 2006 国际大学生编程竞赛题目详解》 ACM（International Collegiate Programming Contest，简称ICPC）是一项全球性的编程竞赛，旨在推动计算机科学教育的发展，激发大学生对算法设计与分析的热情。2006年的...
ACM.rar_ACM_ACM PDF_ACM pdf
09-14
在ACM中，它常用于解决最优化问题，如背包问题、最长公共子序列等。关键在于找出状态转移方程，并构造合适的记忆化数据结构。 3. **分治算法**：将大问题分解为若干个小问题，分别解决后再合并结果。分治策略在ACM...
ACM学习资源和资料收集.docx
最新发布
05-21
- **实例**: 最长公共子序列。 10. **高精度运算** - **概念**: 处理超过标准数据类型长度的数字。 - **应用**: 大整数加减乘除。 #### 三、ACM竞赛题型分析 - **动态规划**: 适用于状态转移清晰的问题。 - **...
最长上升子序列模型练习
csdnwqy030429的博客
02-02 652
最长上升子序列模型练习怪盗基德的滑翔翼登山友好城市最大上升子序列和拦截导弹导弹防御系统最长公共上升子序列 怪盗基德的滑翔翼 题目链接：怪盗基德的滑翔翼 分析：这道题还是比较简单的，我们只需要求一遍最长上升子序列(倒着看就是怪盗基德从最后的一个点滑翔到最前面的一个点)，再求一遍最长下降子序列，这两者中的最小值就是答案。 代码实现： 数据范围较小，朴素做法就能过 #include<iostream> using namespace std; const int N=110; int a[N],f[N
最长上升子序列模型（LIS）
m0_74120503的博客
01-18 2596
最长上升子序列模型就像它的名字一样，用来从区间中找出最长上升的子序列。它主要用来处理区间中的挑选问题，可以处理上升序列也可以处理下降序列，原序列本身的顺序并不重要。
kuangbin专题十二 HDU1257 LST 最长上升子序列模板题
Start_to_crazy的博客
01-30 393
题意： 中文题。 题解： 其实就是个最长上升子序列模板题。下面是两种写法，等会去想一下贪心怎么做的，和O(nlogn)的写法。 这个O(n^2)的写法给你们解释一下： 第一种是人人为我的思路 (j帮助i)。就是确定子序列终点，把其前面每一个小于它的值的位置的状态数组用来更新它本身。 而第二种是我为人人的思路（就是i帮助j） 。就是确定子序列起点，把
简单编程题目连载（九）——最长上升子序列
非专人士的专栏
01-22 900
最长上升子序列
最长上升子序列 and 最长公共子序列 问题模板
weixin_30369087的博客
08-06 86
两种求最长上升子序列问题 第一种：定义dp[i]=以a[i]为末尾的最长上升子序列问题的长度 第二种：定义dp[i]=长度为i+1的上升 子序列 中末尾元素的最小值 #include <cstdio> #include <iostream> using namespace std; const int INF = 0x3f3f3f3...
【动态规划】—— 最长上升子序列模型
forever_bryant的博客
07-17 530
【动态规划】—— 最长上升子序列模型
最长上升子序列模型
m0_57193124的博客
05-11 230
模型4：最长上升子序列模型 题目1: 怪盗基德的滑翔翼 分析:
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值