【序列dp】最长上升子序列（一）

已于 2023-06-20 19:56:05 修改
阅读量465 收藏 2
点赞数
分类专栏： 蓝桥杯 文章标签： java 算法 开发语言 动态规划
于 2023-06-20 19:49:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Trae1ounG/article/details/131314229
版权

文章目录

最长上升子序列-序列dp

  • 什么是序列相关的 DP ？
  • 序列相关 DP，顾名思义，就是将动态规划算法用于数组或者字符串上，进行相关具体问题的求解
  • 何时可以使用序列相关的 DP？
  • 当题目求解以下内容时，可以考虑使用序列相关的 DP
  • 给定两个字符串，求最长/大的某种值
  • 给定数组，求最长/大的某种值

此外，在使用序列相关的 DP 的时候，我们还需要注意到，这是一类的动态规划，所以需要满足动态规划的两种重要条件
最长上升子序列问题是一个经典的动态规划问题，目标是在给定序列中找到一个最长的升序子序列。

问题描述：
给定一个序列，要求找到其中最长的一个升序子序列。也就是说，要找到一个子序列，使得其中的元素按照从小到大的顺序排列，并且长度最长。

解决方法：
一种常用的动态规划方法来解决最长上升子序列问题是使用一个辅助数组dp。dp[i]表示以第i个元素结尾的最长上升子序列的长度。

具体步骤如下：

  1. 初始化dp数组为1，所有的元素初始都有一个长度为1的子序列。
  2. 对于每个位置i，从0到i-1遍历前面的元素j：
    • 如果第i个元素大于第j个元素，说明可以将第i个元素添加到以第j个元素结尾的子序列中，形成一个更长的子序列。
      • 此时更新dp[i] = max(dp[i], dp[j] + 1)，表示以第i个元素结尾的子序列的长度。
  3. 遍历所有的dp[i]，找到其中的最大值max_length，即为最长上升子序列的长度。

最后，根据dp数组的记录，可以逆向构造最长上升子序列的元素。

总结：
最长上升子序列问题可以通过动态规划的方法解决，使用dp数组记录以每个位置结尾的最长上升子序列长度，通过逐个比较元素大小，不断更新dp数组。最终得到最长上升子序列的长度，及其中的元素。这个问题是经典的算法问题，在实际应用中有广泛的应用。

概览

在这里插入图片描述

895 最长上升子序列-O(n^2)

在这里插入图片描述

集合表示：所有以a[i]结尾的最长上升子序列

属性为Max即长度的最大值

考虑如何计算，一般考虑最后一个点，可以取

空，a[0]，a[1]，…，a[i-1]

但是有的区间为空，当a[k] >= a[i]时，即不满足上升子序列

计算时：a[i]=Math.max(满足条件的a[k])

最终答案，遍历所有下标，选取最长的上升子序列

package acwing_plus.动规.最长上升子序列;

import java.util.Scanner;

/**
 * @author ty
 * @create 2023-03-30 21:35
 */
public class 最长上升子序列 {
    static int N = 1010;
    static int[] a = new int[N];
    static int[] f = new int[N];
    static int n;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 1;i <= n;i++) {
            a[i] = sc.nextInt();
        }
        for (int i = 1;i <= n;i++) {
            f[i] = 1;
            for (int j = 1;j < i;j++) {
                if (a[i] > a[j]) {
                    f[i] = Math.max(f[j] + 1,f[i]);
                }
            }
        }
        int res = 0;
        for (int i = 1;i <= n;i++) {
            //res是所有不同a[i]结尾的最大值
            res = Math.max(res,f[i]);
        }
        System.out.println(res);
    }
}

1017 怪盗基德的滑翔翼

在这里插入图片描述

在这里插入图片描述

LIS的双向求解，主要掌握求最长下降序列，即反向求解最长上升序列

package acwing_plus.动规.最长上升子序列;

import java.util.Scanner;

/**
 * @author ty
 * @create 2023-03-30 21:57
 */
public class 怪盗基德 {
    static int N = 110;
    static int n;
    static int[] a = new int[N];
    static int[] f = new int[N];
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        while (T-- > 0 ) {
            n = sc.nextInt();
            for (int i = 1;i <= n;i++) {
                a[i] = sc.nextInt();
            }
            //正向求解LIS问题
            int res = 0;
            for (int i = 1;i <= n;i++) {
                f[i] = 1;
                for (int j = 1;j < i;j++) {
                    if (a[j] < a[i]){
                        f[i] = Math.max(f[j] + 1,f[i]);
                    }
                }
                res = Math.max(res,f[i]);
            }
            //反向求解LIS
            for (int i = n;i >= 1;i--) {
                f[i] = 1;
                for (int j = n;j > i;j--) {
                    if (a[i] > a[j]) {
                        f[i] = Math.max(f[i],f[j] + 1);
                    }
                }
                res = Math.max(f[i],res);
            }
            System.out.println(res);
        }
    }
}

1014 登山

在这里插入图片描述

在这里插入图片描述

自己实现，由怪盗基德思想实现

package acwing_plus.动规.最长上升子序列;

import java.util.Scanner;

/**
 * @author ty
 * @create 2023-03-30 23:10
 */
public class 登山 {
    static int N = 1010;
    static int[] a = new int[N];
    static int[] l = new int[N];
    static int[] r = new int[N];
    static int n;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 1;i <= n;i++ ) {
            a[i] = sc.nextInt();
        }
        int res = 0;
        //求最长下降子序列长度
        for (int i = n;i >= 1;i-- ) {
            r[i] = 1;
            for (int j = n;j > i;j--) {
                if (a[i] > a[j]) {
                    r[i] = Math.max(r[j] + 1,r[i]);
                }
            }
        }
        //求最长上升子序列长度
        for (int i = 1;i <= n;i++) {
            l[i] = 1;
            for (int j = 1;j < i;j++) {
                if (a[i] > a[j]) {
                    l[i] = Math.max(l[i],l[j] + 1);
                }
            }
        }
        for (int i = 1;i <= n;i++) {
            res = Math.max(l[i]+r[i] - 1,res);
        }
        System.out.println(res);
    }
}

482 合唱队形

在这里插入图片描述

登山的变体，求整个队列个数-max(每个点的最大上升序列+最大下降序列-1)

package acwing_plus.动规.最长上升子序列;

import java.util.Scanner;

/**
 * @author ty
 * @create 2023-03-31 0:36
 */
public class 合唱队形 {
    static int N = 110;
    static int n;
    static int[] a = new int[N];
    static int[] l = new int[N];
    static int[] r = new int[N];
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 1;i <= n;i++) {
            a[i] = sc.nextInt();
        }
        for (int i = 1;i <= n;i++) {
            l[i] = 1;
            for (int j = 1;j < i;j++) {
                if (a[i] > a[j]) {
                    l[i] = Math.max(l[i],l[j] + 1);
                }
            }
        }
        for (int i = n;i >= 1;i--) {
            r[i] = 1;
            for (int j = n;j >= i;j--) {
                if (a[i] > a[j]) {
                    r[i] = Math.max(r[i],r[j] + 1);
                }
            }
        }
        int res = 0;
        for (int i = 1;i <= n;i++) {
            res =  Math.max(res,l[i] + r[i] -1);
        }
        System.out.println(n - res);
    }
}

1012 友好城市

在这里插入图片描述

在这里插入图片描述

package acwing_plus.动规.最长上升子序列;

import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

/**
 * @author ty
 * @create 2023-03-31 9:40
 */
public class 友好城市 {
    static int N = 5010;
    static Edge[] a = new Edge[N];
    static int[] f = new int[N];
    static int INF = (int)-1e9;
    static class Edge {
        int u,d;

        public Edge(int u, int d) {
            this.u = u;
            this.d = d;
        }
    }
    static int n;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 1;i <= n;i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            a[i] = new Edge(x,y);
        }
        //按下面排好序
        Arrays.sort(a, 1, n + 1, new Comparator<Edge>() {
            @Override
            public int compare(Edge o1, Edge o2) {
                return o1.d - o2.d;
            }
        });
        //上面的点一定是上升序列，才能成立
        //此处寻找最长上升子序列
        for (int i = 1;i <= n;i++) {
            f[i] = 1;
            for (int j = 1;j < i;j++) {
                if (a[i].u > a[j].u) {
                    f[i] = Math.max(f[i],f[j] + 1);
                }
            }
        }
        int res = 0;
        for (int i = 1;i <= n;i++) {
            res = Math.max(res,f[i]);
        }
        System.out.println(res);
    }
}

Trae1ounG
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
最长上升子序列——DP、二分法
weixin_50666824的博客
03-05 1605
1、题目描述 https://leetcode-cn.com/problems/longest-increasing-subsequence 2、解题思路 2.1 DP动态规划 根据题意。我们可以发现，下标i处的最长上升子序列长度与前面下标的最长上升子序列长度有关。 比如nums[i]>nums[j] 那么 此时i位置的最长上身子序列长度等于 j位置最长序列长度+1； 动态规划五部曲： 1、dp[i]的含义： dp[i]表示从0~i下标范围内的最大上升子序列的长度； 2、状态转移
DP-LeetCode1143. 最长公共子序列（Python）
12-21
1、题目描述 2、代码详解 自下向上 class Solution(object): # Modify the original triangle, bottom-up def minimumTotal(self, triangle): """ :type triangle: List[List[int]] :rtype: int ...
dp之最长上升子序列
yuanxinya_的博客
10-16 332
动态规划
【DP】最长上升子序列
SY奇星的OI博客
09-14 153
最长上升子序列（Longest Increasing Subsequence，简称LIS）是一个在数列中寻找一个子序列，使得这个子序列中的元素按照升序/降序排列，并且长度最长。
最长上升子序列问题（LIS问题）与最长不上升子序列问题的四种方法（c++ 模板代码）
ylh的博客
02-02 2596
LIS问题与 L不IS问题 的模板代码，四种方法，动态规划，树状数组，线段树，二分查找
最长上升子序列（LIS）算法
热门推荐
紫芝的博客
07-25 1万+
LIS定义 LIS（Longest Increasing Subsequence）最长上升子序列  一个数的序列bi，当b1 &lt; b2 &lt; … &lt; bS的时候，我们称这个序列是上升的。 对于给定的一个序列(a1, a2, …, aN)，我们可以得到一些上升的子序列(ai1, ai2, …, aiK)， 这里1 &lt;= i1 &lt; i2 &lt; … &lt; iK ...
最长上升子序列.docx
最新发布
04-12
假设我们有一个数组 `nums`，其中 `dp[i]` 表示以 `nums[i]` 结尾的最长上升子序列的长度。那么我们可以按照以下步骤计算 `dp` 数组： 1. 初始化 `dp[i]` 为 1，因为每个单独的元素都构成一个长度为 1 的上升子序列...
DP、二分-LeetCode300. 最长上升子序列（Python）
12-21
给定一个无序的整数数组，找到其中最长上升子序列的长度。 输入: [10,9,2,5,3,7,101,18] 输出: 4  解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。 说明:可能会有多种最长上升子序列的组合，你只需要输出...
Python求两个字符串最长公共子序列代码实例
09-17
在编程领域，字符串操作是常见任务之一，而求解两个字符串的最长公共子序列（Longest Common Subsequence, LCS）是字符串处理中的一个重要问题。这个问题涉及到动态规划算法，它能有效地解决这类具有最优子结构和...
最长上升子序列模型DP（LIS）
viclao的专栏
11-28 69
LIS
动态规划——最长上升子序列
INGg__的博客
02-25 3248
首先：什么是最长上升子序列？ 最长上升子序列是指：给定一个长度为N的数列，求数值严格单调递增的子序列的长度最长是多少。 **状态表示：**所有以i结尾的严格单调上升的子序列的长度的集合（MAX） **状态计算：**以倒数第二个元素为分界（因为最后一个元素肯定是i）（如果倒数第二位是第0位的话，也说明这个上升子序列就只有一个元素，也就是a[i]a[i]a[i]；如果是一般情况，只需要判断在严格单调上升的前提下，枚举以倒数第二个元素为结尾的上升子序列长度和加上第i个元素的长度求一个最大值就行（可能说的有点问题，
Leetcode——最长上升子序列
IT荻的博客
01-17 899
300.给定一个无序的整数数组，找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。 说明: 可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。 你算法的时间复杂度应该为 O(n2) 。 进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗? 思路： 1.D...
DP之最长上升子序列
柯微
11-20 345
前言：我们先了解一下最长连续递增子序列的求解！ #include<bits/stdc++.h> using namespace std; //求最长连续递增序列 #define maxn 100000 int n,a[maxn],dp[maxn];//dp[i]即前i个元素的上升子序列的长度 int main(){ cin>>n; for(int i=1;i&l...
动规(1)-最长上升子序列
abraham的博客
05-19 1万+
动规1：最长上升子序列 描述 一个数的序列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最长上升子序列
AAAAAAAC的博客
04-17 235
1、题意：对于输入的数组，输出其上升子序列最长的长度 2、思路：对开始到结束，储存当前位置为子序列最后一位时最长的长度，当其位置最长长度为前一个比当前位置数值小的位置的长度+1； 3、感想：此题老师上课讲过，但是自己做的动态规划第一题，是思维打开的开端，比较易接受。 4、代码： #include using namespace std; int main() {     int n
01:最长上升子序列
lml11111的博客
03-27 282
01:最长上升子序列 总时间限制: 2000ms 内存限制: 65536kB 描述一个数的序列bi，当b1 b2 bS的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1 i1 i2 iK  你的任务，就是对于给定的序列，求出最长上升子
ACM题解——动态规划系列——最长升序子序列
Biangbangbing的博客
02-28 757
ACM题解——动态规划系列——最长升序子序列 题目描述 A numeric sequence ofaiis ordered ifa1<a2< ... <aN. Let the subsequence of the given numeric sequence (a1,a2, ...,aN) be any sequence (ai1,ai2, ...,aiK), where 1 <=i1<i2< ... <iK<=N...
最长上升子序列（DP）
Orz~~Orz
07-02 1067
最长上升子序列 Time Limit: 3000ms   Memory limit: 65536K  有疑问？点这里^_^ 题目描述 一个数的序列bi，当b1 2 S的时候，我们称这个序列是上升的。对于给定的一个序列(a1, a2, ..., aN)，我们可以得到一些上升的子序列(ai1, ai2, ..., aiK)，这里1<= i1 2 K 你的任务，就是
最长上升子序列(dp入门题)
li_wen_zhuo的博客
03-26 571
给定一个长度为N的数列，求数值严格单调递增的子序列的长度最长是多少。 输入格式 第一行包含整数N。 第二行包含N个整数，表示完整序列。 输出格式 输出一个整数，表示最大长度。 数据范围 1≤ N ≤1000， −109≤ 数列中的数 ≤109 输入样例 7 3 1 2 1 8 5 6 输出样例 4 题目分析： 状态表示：f[i]表示从第一个数开始算，以a[i]为结尾的最大上升...
求一个序列的最长上升子序列。
04-07
我们定义一个数组 dp，其中 dp[i] 表示以第 i 个元素为结尾的最长上升子序列的长度。初始时，dp 数组中的所有元素均为 1，因为每个元素本身都可以构成长度为 1 的上升子序列。 接下来，我们从前往后遍历序列，对于...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值