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

最新推荐文章于 2023-10-30 16:06:05 发布
最新推荐文章于 2023-10-30 16:06:05 发布
阅读量417 收藏
点赞数
分类专栏： 蓝桥杯 文章标签： java 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Trae1ounG/article/details/131314389
版权
文章介绍了使用动态规划解决序列相关问题的思路，包括最长上升子序列的求解，以及在拦截导弹问题中的应用，讨论了如何找到最长下降子序列并计算能覆盖整个序列的子序列数量。此外，还探讨了导弹防御系统问题的解决方案，即如何用最少的上升和下降子序列覆盖序列，并展示了最长公共上升子序列的优化算法，降低了时间复杂度。
摘要由CSDN通过智能技术生成

文章目录

最长上升子序列-序列dp

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

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

1016 最大上升子序列和

在这里插入图片描述

在这里插入图片描述

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

import java.util.Scanner;

/**
 * @author ty
 * @create 2023-03-31 10:00
 */
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] = a[i];
            for (int j = 1;j < i;j++) {
                if (a[i] > a[j]) {
                    f[i] = Math.max(f[i],f[j] + a[i]);
                }
            }
        }
        int res = 0;
        for (int i = 1;i <= n;i++) {
            res = Math.max(res,f[i]);
        }
        System.out.println(res);
    }
}

1010. 拦截导弹

在这里插入图片描述

第一问：最长下降子序列

第二问：多少个最长下降子序列能覆盖整个序列

在这里插入图片描述

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

import java.util.Scanner;

/**
 * @author ty
 * @create 2023-03-31 11:29
 */
public class 拦截导弹 {
    static int N =  1010;
    static int n;
    static int[] q = new int[N];
    static int[] f = new int[N];
    static int[] g = new int[N];
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] line = sc.nextLine().split(" ");
        n = line.length;
        for (int i = 0;i < n;i++) {
            q[i] = Integer.parseInt(line[i]);
        }
        //先求最长下降子序列
        int res = 0;
        for (int i = n-1;i >= 0;i--) {
            f[i] = 1;
            for (int j = n-1;j > i;j--) {
                //题目要求是不高于上一个炮弹，所以此处下降序列可以连续相等
                if (q[i] >= q[j]) {
                    f[i] = Math.max(f[i],f[j] + 1);
                }
            }
            res = Math.max(res,f[i]);
        }
        System.out.println(res);
        //g数组存现有的子序列
        //cnt表示当前子序列个数
        int cnt = 0;
        for (int i = 0;i < n;i++) {
            int k = 0;
            //找到第一个最长下降子序列最后一个值，大于等于q[i]的
            while (k < cnt && g[k] < q[i]) k++;
            g[k] = q[i];
            //没有序列，能存储当前元素
            if (k >= cnt) {
                cnt++;
            }
        }
        System.out.println(cnt);
    }
}

187. 导弹防御系统

在这里插入图片描述

比1010变化：拦截系统新增可以单调上升的选择

即最少可以用多少个上升子序列和下降子序列将整个序列覆盖掉

此时不能用贪心，因为最开始还要面临选择上升还是下降，这是没法做到的，只能使用暴搜

在这里插入图片描述

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

import java.util.Scanner;

/**
 * @author ty
 * @create 2023-03-31 12:45
 */
public class 导弹防御系统 {
    static int N = 55;
    static int[] q = new int[N];
    static int[] up = new int[N];
    static int[] down = new int[N];
    static int n;
    //记录全局最小值
    static int ans;

    /**
     * @param u 当前枚举到第几个数
     * @param su 当前上升子序列的个数
     * @param sd 当前下降子序列的个数
     */
    private static void dfs(int u, int su, int sd) {
        if (su + sd  >= ans) return;//超出最小的ans
        //找到方案
        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;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while ((n = sc.nextInt()) != 0){
            ans = n;
            for (int i = 0;i < n;i++) {
                q[i] = sc.nextInt();
            }
            dfs(0,0,0);
            System.out.println(ans);
        };
    }
}

272.最长公共上升子序列

最长公共子序列在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

划分方式

n^3 TLE
package acwing_plus.动规.最长上升子序列;

import java.util.Scanner;

/**
 * @author ty
 * @create 2023-03-31 14:22
 */
public class 最长公共上升子序列 {
    static int N = 3010;
    static int n;
    static int[] a = new int[N];
    static int[] b = new int[N];
    static int[][] f = new int[N][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++) b[i] = sc.nextInt();
        /*
        f[i][j]表示所有第一个序列中前i个字母和第二个序列中前j个字母构成的
            且以b[j]结尾的公共上升子序列的最长长度
        f[i][j]来自于
        情况一：不包含a[i]=>f[i-1][j]
        情况二：包含a[i]，前提a[i]==b[j]
                ->再按照倒数第二个数的位置进行划分
                ->倒数第二个数的位置可以取，空值（即只有b[j]一个元素),b[1],b[2]...b[j-1]
                ->需要满足对于上述位置k，b[j]>b[k]
                =>f[i,j] = max(f[i,j],f[i,k]+1)
        最终答案是max(f[n,i]),i = 1...n
         */
        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] = Math.max(f[i][j], 1);
                    for (int k = 1; k < j; k++) {
                        if (b[j] > b[k]) {
                            f[i][j] = Math.max(f[i][k] + 1, f[i][j]);
                        }
                    }
                }
            }
        }
        int res = 0;
        for (int i = 1; i <= n; i++) {
            res = Math.max(res, f[n][i]);
        }
        System.out.println(res);
    }
}
优化
import java.util.Scanner;

/**
 * @author ty
 * @create 2023-03-31 14:22
 */
public class Main {
    static int N = 3010;
    static int n;
    static int[] a = new int[N];
    static int[] b = new int[N];
    static int[][] f = new int[N][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++) b[i] = sc.nextInt();
        /*
        f[i][j]表示所有第一个序列中前i个字母和第二个序列中前j个字母构成的
            且以b[j]结尾的公共上升子序列的最长长度
        f[i][j]来自于
        情况一：不包含a[i]=>f[i-1][j]
        情况二：包含a[i]，前提a[i]==b[j]
                ->再按照倒数第二个数的位置进行划分
                ->倒数第二个数的位置可以取，空值（即只有b[j]一个元素),b[1],b[2]...b[j-1]
                ->需要满足对于上述位置k，b[j]>b[k]
                =>f[i,j] = max(f[i,j],f[i,k]+1)
        最终答案是max(f[n,i]),i = 1...n
         */
        for (int i = 1; i <= n; i++) {
            int maxv = 1;//表示a[i]==b[j]，1到j-1在满足a[i]>b[k]条件下的最大值
            for (int j = 1; j <= n; j++) {
                f[i][j] = f[i - 1][j];
                //第二种
                if (a[i] == b[j]) {
                    f[i][j] = Math.max(f[i][j], maxv);
                }
                /*
                这里的理解是，因为本质上之前更新的时候是b[k] < b[j]
                转换为b[k]<a[i]是因为b[j]==a[j],即选择到a[i]
                但是此时更新时，a[i]是我们将要寻找的b[j],可以理解为在执行到
                a[i]==b[j]之前的更新，都是没有选用a[i]的情况下的
                 */
                if (b[j] < a[i]) maxv = Math.max(maxv, f[i-1][j] + 1);

            }
        }
        int res = 0;
        for (int i = 1; i <= n; i++) {
            res = Math.max(res, f[n][i]);
        }
        System.out.println(res);
    }
}

Trae1ounG
关注
专栏目录
【DP】最长上升子序列
qq_43398760的博客
03-04 657
Description 设有由n(1≤n≤200)个不相同的整数组成的数列，记为:b(1)、b(2)、……、b(n)且b(i)≠b(j)(i≠j)，若存在i_1&amp;lt;i_2&amp;lt;i_3&amp;lt;…&amp;lt;i_ei1​&lt;i2​&lt;i3​&lt;…&lt;ie​且有b(i_1)&amp;lt;b(i_2)&amp;lt;…&amp;lt;b(i_e)b(i...
Dp——最长上升子串、最长上升子序列
popwe的博客
07-24 730
最长上升子串 一、题目描述 描述 一个数的子串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, 5, 9)等等。这些子串中最长的长度是3，比如子序列(3, 5, 9).
最长上升子序列（DP）
za30312的博客
08-17 421
问题描述 一个数的序列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)等等。这些子序列
【dp】最长上升子序列
最新发布
qq_62525850的博客
10-30 194
dp[i]表示从0~i中的最大递增子序列，因此遍历时只需要查找在i之前比num[i]小的数。当数据规模增大时，传统方法就会出现超时，因此采用堆栈的方法对递增子序列查找进行优化。该方法的时间复杂度为O(n*n)
最长上升子序列 dp
king_fdy的博客
02-20 141
//最长上升子序列 #include <iostream> #include<algorithm> using namespace std; const int N =1010; int n; int a[N],f[N]; int main() { while(scanf("%d",&n)!=EOF){ for(int i=1;i<=n;i++)...
最长上升子序列（dp）
H煊的博客
07-01 294
求一个长度为n的最长上升子序列的长度（LIS），即对于任意的i 思路：通过dp求解，我们首先定义：dp[i]=以a[i]为末尾的最长上升子序列的长度； 则以a[i]结尾的上升子序列是： 1）只包含a[i]的子序列 2）在满足j 这二者之一，即状态转移方程是：dp=max{1,dp[j]+1|j 时间复杂度：O(n^2) 代码： //输入 int n; int
DP、二分-LeetCode300. 最长上升子序列（Python）
12-21
在这个问题中，我们可以定义一个数组 `dp`，其中 `dp[i]` 表示以 `nums[i]` 结尾的最长上升子序列的长度。初始状态下，每个元素都以自身构成一个上升子序列，所以 `dp` 数组的初始值为1。 ```python def ...
求出最长上升子序列中各个元素
06-06
我们可以定义一个数组`dp`，其中`dp[i]`表示以第`i`个元素结尾的最长上升子序列的长度。初始时，所有`dp[i]`都设为1，因为每个元素本身都是一个长度为1的上升子序列。 然后，对于每个元素，我们可以遍历在其之前的...
最长上升子序列——DP、二分法
weixin_50666824的博客
03-05 1692
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、状态转移
YTU3135--最长上升子序列（dp）
我家有个zz~
05-16 566
lis......
最长上升子序列(DP)
weixin_63739349的博客
04-04 703
给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。 输入格式 第一行包含整数 N。 第二行包含 N 个整数，表示完整序列。 输出格式 输出一个整数，表示最大长度。 数据范围 1≤N≤100000， −109≤数列中的数≤109 输入样例： 7 3 1 2 1 8 5 6 输出样例： 4 基本思路 首先，求最长上升子序列（后面称 LIS ）的问题和它的子问题有这样的依赖关系： 上图这样就可以求得序列3 1 2 1 8 5 6的 LIS 长度是 4 ，.
Leetcode 300. 最长上升子序列 DP
Evildoer_llc的博客
04-08 199
给定一个无序的整数数组，找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101]， 它的长度是4 说明: 可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。 你算法的时间复杂度应该为O(n2) 。 进阶:你能将算法的时间复杂度降低到O(nlogn...
acm pku 2533 Longest Ordered Subsequence 动态规划
Manio
09-25 1725
Longest Ordered Subsequence Time Limit:2000MS  Memory Limit:65536KTotal Submit:2685 Accepted:964 DescriptionA numeric sequence of ai is ordered if a1 a2 aN. Let the subsequence of the given numeric
【openjudge 1759】最长上升子序列（dp）
reverie_mjp的博客
11-01 828
松叶正秋琴韵响，菱花初晓镜光寒
Codevs 2188 最长上升子序列 dp
QER 的博客
10-30 302
Codevs 2188 最长上升子序列对不合法的数字不作处理。continue#include <iostream> #include <cstdio> #include <cstring> #include <cstdlib> using namespace std;#define MAXN (200000+10) int a[MAXN], dp[MAXN];#define INF (1e9)in
最长上升子序列—DP
m0_72522122的博客
12-20 101
【代码】最长上升子序列—DP。
最长上升子序列（dp--O（n*logn））
WYwysun的博客
04-02 344
O(n^2)时递推关系简单， 代码实现也简洁， 唯一的问题是n ^ 2的复杂度在题目给的数据量较大时会超时。 这个问题可以用二分来优化。 做法是构造出一个新的有序的DP数列， 用原数列中的数从左到右维护更新新数列。 初始时DP[0] = s[0]， 从i = 1时遍历原数列， 将每个遍历的数与DP数列的末尾进行比较， 如果大于末尾， 则把DP数列长度提1将s[i]放在DP数列的最后， 如果小...
寻找最长上升子序列的长度
我们可以定义一个数组dp，其中dp[i]表示以第i个元素结尾的最长上升子序列的长度。初始化dp数组，所有值设为1，因为每个元素本身都可以构成一个长度为1的上升子序列。 然后，我们遍历整个序列，对于每个元素i，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值