【动态规划】线性DP

最新推荐文章于 2024-07-30 20:12:32 发布
最新推荐文章于 2024-07-30 20:12:32 发布
阅读量6.5k 收藏 176
点赞数 43
分类专栏： 算法 文章标签： 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42638946/article/details/117324704
版权

线性DP

1. 线性DP

定义

  • 这里的定义只是一个概述，所谓的线性DP是指我们的递推方程是存在一个线性的递推关系。可以是一维线性的、二维线性的、三维线性的、…

  • 最长上升子序列模型属于线性DP。

2. AcWing上的线性DP题目

AcWing 898. 数字三角形

问题描述

分析

在这里插入图片描述

代码

  • C++
#include <iostream>

using namespace std;

const int N = 510;

int n;
int f[N][N];  // 最初存储的是三角形中的值

int main() {

    cin >> n;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= i; j++)
            cin >> f[i][j];

    for (int i = n - 1; i; i--)
        for (int j = 1; j <= i; j++)
            f[i][j] += max(f[i + 1][j], f[i + 1][j + 1]);

    cout << f[1][1] << endl;

    return 0;
}

AcWing 895. 最长上升子序列

问题描述

分析

在这里插入图片描述

代码

  • C++
// Created by WXX on 2021/2/26 14:50
#include <iostream>

using namespace std;

const int N = 1010;  // 多开几个数据，防止数组下标越界

int n;  // 输入数据个数
int a[N], f[N];  // a存储读入的数据，f是动态规划数据

// 时间复杂度：O(n^2)
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[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]);

    cout << res << endl;
    return 0;
}
  • Java
import java.util.Scanner;

/**
 * Created by WXX on 2021/2/26 15:01
 * 时间复杂度：O(n^2)
 */
public class Main {

    public static final int N = 1010;  // 多开几个数据，防止数组下标越界

    static int n;  // 输入数据个数
    static int[] a = new int[N], f = new int[N];  // a存储读入的数据，f是动态规划数据

    public static void main(String[] args) {

        Scanner sn = new Scanner(System.in);
        n = sn.nextInt();
        for (int i = 1; i <= n; i++) a[i] = sn.nextInt();

        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[i], f[j] + 1);
        }

        int res = 0;  // 最长上升子序列结尾位置不一定是数组的末尾
        for (int i = 1; i <= n; i++) res = Math.max(res, f[i]);

        System.out.println(res);
    }
}

AcWing 896. 最长上升子序列 II

问题描述

分析

  • 本题和上一题唯一的区别就是输入数组的大小增大了100倍，从最多1000个数据变成了最多100000个数据，如果还采用上述方法，则会TLE（超时），需要采用另外一种做法。

  • 我们使用一个数组q来记录额外的信息，从前向后考察输入的数据（存储在a数组中），用q[t]记录考察到当前元素是长度为t的上升子序列结尾的最小值，则根据定义可以推出 q 是一个严格单调上升的子序列，这可以用反证法进行证明。如下图：

在这里插入图片描述

知道了q是严格单调递增的，于是我们可以考虑使用二分。

  • 对于当前考察的元素 a[i]，在q数组中找到小于a[i]的最大的数，假设为q[t]，则q[t+1]一定大于等于a[i]（否则q[t+1]就是小于a[i]的最大的数），然后将q[t+1]更新为a[i]，并在此过程中更新我们的答案。

  • 这种做法的时间复杂度是 O ( n ∗ l o g ( n ) ) O(n*log(n)) O(n∗log(n)) 的。

代码

  • C++
// Created by WXX on 2021/2/26 14:50
#include <iostream>

using namespace std;

const int N = 100010;

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

// 时间复杂度：O(n^log(n))
int main() {

    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%d", &a[i]);

    int res = 0;
    q[0] = -2e9;  // q[0]设为负无穷，防止数组越界
    for (int i = 0; i < n; i++) {
        int l = 0, r = res;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (q[mid] < a[i]) l = mid;
            else r = mid - 1;
        }
        res = max(res, r + 1);
        q[r + 1]  = a[i];  // q[r]是小于a[i]的最大的数，则q[r+1]是大于等于a[i]的最小的数
    }

    cout << res << endl;
    return 0;
}
  • Java
import java.util.Scanner;

/**
 * Created by WXX on 2021/2/26 15:35
 * 时间复杂度：O(n^log(n))
 */
public class Main {

    public static final int N = 100010;

    static int n;
    static int[] a = new int[N], q = new int[N];

    public static void main(String[] args) {

        Scanner sn = new Scanner(System.in);
        n = sn.nextInt();
        for (int i = 0; i < n; i++) a[i] = sn.nextInt();

        int res = 0;
        q[0] = Integer.MIN_VALUE;  // q[0]设为负无穷，防止数组越界
        for (int i = 0; i < n; i++) {
            int l = 0, r = res;
            while (l < r) {
                int mid = l + r + 1 >> 1;
                if (q[mid] < a[i]) l = mid;
                else r = mid - 1;
            }
            res = Math.max(res, r + 1);
            q[r + 1] = a[i];  // q[r]是小于a[i]的最大的数，则q[r+1]是大于等于a[i]的最小的数
        }

        System.out.println(res);
    }
}

AcWing 897. 最长公共子序列

问题描述

分析

在这里插入图片描述

代码

  • C++
// Created by WXX on 2021/2/26 16:30
#include <iostream>

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\n", f[n][m]);
    return 0;
}
  • Java
import java.util.Scanner;

/**
 * Created by WXX on 2021/2/26 16:47
 */
public class Main {

    public static final int N = 1010;

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

    public static void main(String[] args) {

        Scanner sn = new Scanner(System.in);
        n = sn.nextInt(); m = sn.nextInt();
        String s1 = " " + sn.next(), s2 = " " +sn.next();  // 为了让下标从1开始
        a = s1.toCharArray(); b = s2.toCharArray();

        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++) {
                f[i][j] = Math.max(f[i - 1][j], f[i][j - 1]);
                if (a[i] == b[j]) f[i][j] = Math.max(f[i][j], f[i - 1][j - 1] + 1);
            }
        System.out.println(f[n][m]);
    }
}

AcWing 902. 最短编辑距离

问题描述

分析

在这里插入图片描述

代码

  • C++
// Created by WXX on 2021/2/27 11:13
#include <iostream>

using namespace std;

const int N = 1010;

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

int main() {

    scanf("%d%s", &n, a + 1);  // 会用到下标i-1，因此字符串从1开始
    scanf("%d%s", &m, b + 1);

    // 初始化
    for (int j = 0; j <= m; j++) f[0][j] = j;  // 将空字符串变为b[1~j]需要j步添加操作
    for (int i = 0; i <= n; i++) f[i][0] = i;  // 将a[1~i]变为空字符串需要i步删除操作

    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++) {
            f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
            if (a[i] == b[j]) f[i][j] = min(f[i][j], f[i - 1][j - 1]);
            else f[i][j] = min(f[i][j], f[i - 1][j - 1] + 1);
        }
    printf("%d\n", f[n][m]);
    return 0;
}
  • Java
import java.util.Scanner;

/**
 * Created by WXX on 2021/2/27 11:20
 */
public class Main {

    public static final int N = 1010;

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

    public static void main(String[] args) {

        Scanner sn = new Scanner(System.in);
        n = sn.nextInt();
        String s1 = " " + sn.next(); a = s1.toCharArray();  // // 会用到下标i-1，因此字符串从1开始
        m = sn.nextInt();
        String s2 = " " + sn.next(); b = s2.toCharArray();

        // 初始化
        for (int j = 0; j <= m; j++) f[0][j] = j;  // 将空字符串变为b[1~j]需要j步添加操作
        for (int i = 0; i <= n; i++) f[i][0] = i;  // 将a[1~i]变为空字符串需要i步删除操作

        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++) {
                f[i][j] = Math.min(f[i - 1][j] + 1, f[i][j - 1] + 1);
                if (a[i] == b[j]) f[i][j] = Math.min(f[i][j], f[i - 1][j - 1]);
                else f[i][j] = Math.min(f[i][j], f[i - 1][j - 1] + 1);
            }
        System.out.println(f[n][m]);
    }
}

AcWing 899. 编辑距离

问题描述

分析

代码

  • C++
// Created by WXX on 2021/2/27 11:30
#include <iostream>
#include <cstring>

using namespace std;

const int N = 15, M = 1010;

int n, m;
int f[N][N];
char str[M][N];

int edit_distance(char a[], char b[]) {

    int la = strlen(a + 1), lb = strlen(b + 1);

    for (int j = 1; j <= lb; j++) f[0][j] = j;
    for (int i = 1; i <= la; i++) f[i][0] = i;

    for (int i = 1; i <= la; i++)
        for (int j = 1; j <= lb; j++) {
            f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
            if (a[i] == b[j]) f[i][j] = min(f[i][j], f[i - 1][j - 1]);
            else f[i][j] = min(f[i][j], f[i - 1][j - 1] + 1);
        }
    return f[la][lb];
}

int main() {

    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) scanf("%s", str[i] + 1);

    while (m--) {
        char s[N];
        int limit;
        scanf("%s%d", s + 1, &limit);

        int res = 0;
        for (int i = 0; i < n; i++)
            if (edit_distance(str[i], s) <= limit)
                res++;

        printf("%d\n", res);
    }
    return 0;
}
  • Java
import java.util.Scanner;

/**
 * Created by WXX on 2021/2/27 11:39
 */
public class Main {

    public static final int N = 15, M = 1010;

    static int n, m;
    static int[][] f = new int[N][N];
    static char[][] str = new char[M][];

    private static int editDistance(char[] a, char[] b) {

        int la = a.length - 1, lb = b.length - 1;

        for (int j = 1; j <= lb; j++) f[0][j] = j;
        for (int i = 1; i <= la; i++) f[i][0] = i;

        for (int i = 1; i <= la; i++)
            for (int j = 1; j <= lb; j++) {
                f[i][j] = Math.min(f[i - 1][j] + 1, f[i][j - 1] + 1);
                if (a[i] == b[j]) f[i][j] = Math.min(f[i][j], f[i - 1][j - 1]);
                else f[i][j] = Math.min(f[i][j], f[i - 1][j - 1] + 1);
            }
        return f[la][lb];
    }

    public static void main(String[] args) {

        Scanner sn = new Scanner(System.in);
        n = sn.nextInt(); m = sn.nextInt();
        for (int i = 0; i < n; i++) {
            String t = " " + sn.next();
            str[i] = t.toCharArray();
        }

        while (m-- != 0) {
            char[] s = (" " + sn.next()).toCharArray();
            int limit = sn.nextInt();

            int res = 0;
            for (int i = 0; i < n; i++)
                if (editDistance(str[i], s) <= limit)
                    res++;

            System.out.println(res);
        }
    }
}
4.1.1 蓝桥杯动态规划之线性DP
tang7mj的博客
01-22 706
线性DP指的是那些状态转移方程可以表示为一系列线性步骤的动态规划问题。这类问题通常可以通过一维或二维数组来实现状态的存储和转移，其核心思想在于“最优子结构”和“重叠子问题”。线性DP是动态规划中最基础的形式，掌握了它，你就能解决很多算法问题。记住，动态规划的关键在于理解如何将问题分解成子问题，并找到合适的状态转移方程。希望这篇博客能帮助你在蓝桥杯中取得更好的成绩！
4.1.1 蓝桥杯之动态规划线性DP课后习题建造房屋
tang7mj的博客
01-22 1613
动态规划（Dynamic Programming）动态规划是解决具有重叠子问题和最优子结构特性的问题的一种方法。在这个问题中，我们通过构建一个表格（dp数组）来避免重复计算相同的子问题，并利用子问题的解来构建原问题的解。状态定义和转移动态规划的核心在于定义“状态”并找出状态之间的转移关系。这个问题教会我们如何精确定义状态（这里是dp[i][j]表示前i条街道上建造j个房屋的方案数），以及如何根据问题的限制（每条街道至少建一个房屋，总预算不超过K元）来确定状态转移方程。组合数学。
动态规划总结—线性DP
weixin_53915786的博客
04-10 687
线性DP DP问题核心就是枚举，枚举出问题所有可能的情况，然后取最优解。DP算法实际上就是设计一种思路（状态转移方程），让程序能高效率地运行出所求结果。 DP解题套路 1.把问题分解成若干子问题； 2.根据题意列出状态转移方程； 3.找出边界； 4.递推求解； 题目总结 T - 最大连续子序列 给定K个整数的序列{ N1, N2, …, NK }，其任意连续子序列可表示为{ Ni, Ni+1, …, Nj }，其中 1 <= i <= j <= K。最大连续子序列是所有连续子序列中元素和最
动态规划之线性DP
CodePanda@GPF的博客
07-26 1487
动态规划之线性DP
线性DP
z545042185的博客
05-31 1075
一、什么是线性DP? 在线性结构上进行状态转移，目标函数为特定变量的线性函数，目的是求目标函数的最大值或最小值。 二、一些例题 1、(1143)最长公共子序列 求两个字符串 S1、S2 的最长公共子序列长度。 dp[i][j]代表 S1 前 i 位和 S2 前 j 位的最长公共子序列长度。 int[][] dp = new int[l1 + 1][l2 + 1]; for (int i = 1; i <= l1; i++) { for (int j = 1; j <= ..
动态规划 —— 线性 DP
热门推荐
Alex_McAvoy的博客
08-20 1万+
【概述】 线性动态规划，是较常见的一类动态规划问题，其是在线性结构上进行状态转移，这类问题不像背包问题、区间DP等有固定的模板。 线性动态规划的目标函数为特定变量的线性函数，约束是这些变量的线性不等式或等式，目的是求目标函数的最大值或最小值。 因此，除了少量问题（如：LIS、LCS、LCIS等）有固定的模板外，大部分都要根据实际问题来推导得出答案。 【常见问题】 序列问题：点击这里 最...
大盗阿福（信息学奥赛一本通）
六级不考550+不改名
09-28 837
题目描述 阿福是一名经验丰富的大盗。趁着月黑风高，阿福打算今晚洗劫一条街上的店铺。 这条街上一共有 N 家店铺，每家店中都有一些现金。 阿福事先调查得知，只有当他同时洗劫了两家相邻的店铺时，街上的报警系统才会启动，然后警察就会蜂拥而至。 作为一向谨慎作案的大盗，阿福不愿意冒着被警察追捕的风险行窃。 他想知道，在不惊动警察的情况下，他今晚最多可以得到多少现金？ 输入格式 输入的第一行是一个整数 T，表示一共有 T 组数据。 接下来的每组数据，第一行是一个整数 N ，表示一共有 N 家店铺。 第二行是 N 个被
算法：动态规划——线性DP（C++)
m0_52530677的博客
04-14 1508
动态规划概述几类典型问题1.最大连续子序列和2.最长不下降子序列3.最长公共子序列4.最长回文子串5.DAG最长路径6.背包问题总结 博客主要参考书：胡凡《算法笔记》 概述 在我看来动态规划就是将一个问题的最优问题分解为子问题的最优解来获得真正的最优解。动态规划问题当中重要的就是： 状态的转化方程：目标态=F（某一状态）。 有边界状态和其值 使用条件：1.有重复的子问题；2.有最优子结构 几类典型问题 1.最大连续子序列和 题目：给定一个序列：S1，S2，S3…Sn，有i,j使得sum=Si+Si+
线性规划等_规划_非线性规划_动态规划_线性规划_整数规划、非线性规划_
10-04
动态规划（Dynamic Programming, DP）是一种用于解决具有重叠子问题和最优子结构特征的最优化问题的方法。它通过将大问题分解为小问题并存储中间结果来避免重复计算。动态规划在路径规划、资源分配和序列决策问题中...
算法合集：动态规划（一）——线性dp
mlgseminent的博客
09-22 1417
动态规划（一）：线性dp一、常规线性dp1、简单的线性dp2、稍复杂的线性dp二、字符串类线性dp专讲 dp可能简单算法中的难度天花板了，但dp并非完全摸不头脑，下面我们从简单题入手来讲解dp 一、常规线性dp 线性dp：从一口气头推到尾，各个子问题相对独立 线性dp一般比较明显的看出递推公式，并且比较容易优化 1、简单的线性dp 简单是指：dp的定义简单，子问题容易找，但实现起来并不简单，有些细节需要注意 1）例题：LeetCode 322 零钱兑换 dp定义比较清晰 维护数组dp，dp[i]表示以
动态规划之——线性DP(入门篇)
最新发布
wh233z的博客
07-30 1540
线性动态规划，是较常见的一类动态规划问题，其是在线性结构上进行状态转移，这类问题不像背包问题、区间DP等有固定的模板。线性动态规划的目标函数为特定变量的线性函数，约束是这些变量的线性不等式或等式，目的是求目标函数的最大值或最小值。
动态规划——线性dp
qq_57150526的博客
10-28 616
动态规划线性dp和区间dp练习讲解和概念介绍
动态规划_线性dp
weixin_30708329的博客
02-21 179
https://www.cnblogs.com/31415926535x/p/10415694.html 线性dp是很基础的一种动态规划，，经典题和他的变种有很多，比如两个串的LCS,LIS,最大子序列和等等，， 线性dp是用来解决一些 线性区间上的最优化问题 ，， 学这里的东西我感觉主要要理解好问题的子问题来写出转移方程，，还有弄清具体的边界条件就行了，， LCS-最长公共子序列 分析 子序列...
动态规划-线性DP
weixin_52278699的博客
07-27 465
线性DP前言一、数字三角形二、最长上升子序列优化版的最长上升子序列三、最长公共子序列四、最短编辑距离总结 前言 线性DP，顾名思义就是在线性空间上进行递推 以下是一些典型的例题 一、数字三角形 给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 输入格式
线性dp
m0_49959202的博客
09-17 618
文章目录线性dp1.算法分析2. 典型例题2.1 LIS模型2.1.1 母题：最长上升子序列2.1.2 扩展1：最长上升子序列打印路径2.1.3 LIS的NlogN做法:贪心2.1.4 求^型序列（既要求最长上升，也要求最长下降）2.1.5 满足LIS性质的应用2.1.6 魔改最长上升子序列状态表示:最长上升子序列和2.1.7 LIS的区间覆盖问题2.1.7.1 用n个最长不下降子序列或者k个最长不上升子序列来覆盖区间：dilworth定理2.1.7.2 用n1个最长上升子序列和n2个最长下降子序列来覆盖区
动态规划DP——线性DP
m0_64378422的博客
07-11 187
目录一、数字三角形二、最长上升子序列 三、最长公共子序列给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。 输入格式第一行包含整数 n，表示数字三角形的层数。接下来 n 行，每行包含若干整数，其中第 i 行表示数字三角形第 i 层包含的整数。输出格式输出一个整数，表示最大的路径数字和。数据范围1≤n≤500, −10000≤三角形中的整数≤10000输入样例： 输出样例： 给定一
DP（1）——线性DP
smileyx2005的博客
07-15 349
贪心只能过样例，DP一般看规律…… Dynamic Programming,teach you how to program your life. DP，全称动态规划(dynamic programming)是运筹学的一个分支，是求解多阶 段决策过程最优化的数学方法。多阶段决策过程，是指这样的一类特殊的活动过程，问题可以按时间顺序分解成若干相互联系的阶段，在每一个阶段都要做出决策，全部 过...
动态规划入门——线性DP
涛涛的个人博客
02-06 765
线性dp入门例题
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值