动态规划1——线性动态规划

于 2025-06-11 20:13:14 发布
阅读量649 收藏 18
点赞数 30
文章标签： 动态规划 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/overload100/article/details/148593096
版权

一、线性动态规划的核心概念

1.1 什么是线性动态规划

线性动态规划（Linear DP）是动态规划的一种基本形式，其特点是状态沿着线性序列（如数组或字符串）单向推进。这类问题通常具有以下特征：

  • 单维/双维状态空间：状态通常表示为 dp[i] 或 dp[i][j]

  • 线性依赖关系：当前状态仅依赖于序列中前一个或多个位置的状态

  • 无后效性：当前状态确定后，后续状态发展不受之前状态影响

1.2 基本解题框架

// 1. 初始化状态数组
vector<int> dp(n, 0); 

// 2. 设置边界条件
dp[0] = base_case; 

// 3. 状态转移（核心）
for(int i = 1; i < n; i++) {
    dp[i] = transition(dp[...]); // 状态转移方程
}

// 4. 获取最终结果
return dp[n-1] or max(dp);

二、经典例题精讲

2.1 最大子段和（Maximum Subarray）

问题描述：给定整数数组，求连续子数组的最大和。
输入格式:第一行是一个正整数N，表示了序列的长度。(N≤200000)
                第二行是用空格分开的N个整数，表示这个序列
输出格式:一个整数，为最大的子段和是多少，子段的最小长度为1
输入样例:7
2  -4   3   -1   2  -4  3
输出样例:4

状态定义：

  • dp[i]：以第 i 个元素结尾的最大子数组和

状态转移方程：

dp[i] = max(dp[i-1] + nums[i], nums[i])

推导过程：

  • 选项1：将当前元素加入前一个子数组（dp[i-1] + nums[i]）

  • 选项2：从当前元素开始新子数组（nums[i]）

  • 取两者最大值作为新状态

代码实现：

int maxSubarraySum(int nums[], int n) {
    int dp[100];
    dp[0] = nums[0];
    int maxSum = dp[0];
    
    for (int i = 1; i < n; i++) {
        dp[i] = max(dp[i-1] + nums[i], nums[i]); // 状态转移
        maxSum = max(maxSum, dp[i]); // 更新全局最大值
    }
    return maxSum;
}

时间复杂度：O(n)
空间复杂度：O(n)（可优化为O(1)）

2.2 最长上升子序列（LIS）

问题描述：求序列中最长的递增子序列长度，

输入格式：第1行是序列的长度N(1 <= N <= 1000)。
                  第2行给出序列中的N个整数，这些整数的取值范围都在0到10000之间
输出格式:一个整数，表示最长上升子序列的长度
输入样例:

7

2  7  3  1  9  4  2
输出样例:

3

状态定义：

  • dp[i]：以第 i 个元素结尾的最长上升子序列长度

状态转移方程：

dp[i] = max(dp[j]) + 1 (0 ≤ j < i 且 nums[j] < nums[i])

推导过程：

  • 遍历所有 j < i

  • 若 nums[j] < nums[i]，则 i 可以接在 j 后面

  • 在所有符合条件的 j 中，取 dp[j] 的最大值加1

代码实现：

int longestIncreasingSubsequence(int a[], int n) {
    vector<int> dp(n, 1); // 初始化为1（每个元素自身是长度为1的序列）
    int maxV = 1;
    
    for (int i = 1; i < n; i++) {
        for (int j = 0; j < i; j++) {
            if (a[j] < a[i]) {
                dp[i] = max(dp[i], dp[j] + 1);
            }
        }
        maxV = max(maxV, dp[i]);
    }
    return maxV;
}

时间复杂度：O(n²)
空间复杂度：O(n)

2.3 最长公共子序列（LCS）

问题描述：求两个序列的最长公共子序列长度。

输入格式：
两行。每行为由大写字母构成的长度不超过1000的字符串，表示序列X和Y。
输出格式：
第一行为一个非负整数。表示所求得的最长公共子序列的长度。若不存在公共子
序列，则输出文件一个整数0。

输入样例：
ABCBDAB
BDCABA


输出样例：

4

状态定义：

  • dp[i][j]：X[0..i-1] 和 Y[0..j-1] 的LCS长度

状态转移方程：

dp[i][j] = {
    dp[i-1][j-1] + 1,             if X[i-1] == Y[j-1]
    max(dp[i-1][j], dp[i][j-1]),  otherwise
}

推导过程：

  • 末尾字符相同：LCS长度+1

  • 末尾字符不同：取两个子问题的最大值

    • 忽略X的末尾（dp[i-1][j]）

    • 忽略Y的末尾（dp[i][j-1]）

代码实现：

int longestCommonSubsequence(string a, string b) {
    int m = a.size(), n = b.size();
    vector<vector<int>> dp(m+1, vector<int>(n+1, 0));
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (a[i-1] == b[j-1]) {
                dp[i][j] = dp[i-1][j-1] + 1;
            } else {
                dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
            }
        }
    }
    return dp[m][n];
}

时间复杂度：O(mn)
空间复杂度：O(mn)

2.4 编辑距离（Edit Distance）

问题描述：设A和B是两个字符串。我们要用最少的字符操作次数，将字符串A转换为字符串B。这里所说的字符操作共有三种:
1、删除一个字符;
2、插入一个字符
3、将一个字符改为另一个字符
对任意的两个字符串A和B，计算出将字符串A变换为字符串B所用的最少字符操作次数。
输入格式：
第一行为字符串A;第二行为字符串B;字符串A和B的长度均小于2000。
输出格式：
只有一个正整数，为最少字符操作次数。

输入样例：
sfdqxbw
gfdgw
输出样例：

4

状态定义：

  • dp[i][j]：将 A[0..i-1] 转换为 B[0..j-1] 的最小操作数

状态转移方程：

dp[i][j] = {
    dp[i-1][j-1],                  if A[i-1] == B[j-1]
    min(
        dp[i-1][j] + 1,    // 删除A[i]
        dp[i][j-1] + 1,    // 插入B[j]
        dp[i-1][j-1] + 1   // 替换A[i]为B[j]
    ), otherwise
}

推导过程：

  • 字符相同：无需操作，继承前状态

  • 字符不同：取三种操作的最小值

    • 删除：消耗1次操作，转化为 dp[i-1][j]

    • 插入：消耗1次操作，转化为 dp[i][j-1]

    • 替换：消耗1次操作，转化为 dp[i-1][j-1]

代码实现：

int editDistance(string a, string b) {
    int m = a.size(), n = b.size();
    vector<vector<int>> dp(m+1, vector<int>(n+1, 0));
    
    // 初始化边界条件
    for (int i = 0; i <= m; i++) dp[i][0] = i;
    for (int j = 0; j <= n; j++) dp[0][j] = j;
    
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (a[i-1] == b[j-1]) {
                dp[i][j] = dp[i-1][j-1];
            } else {
                dp[i][j] = min({
                    dp[i-1][j] + 1,   // 删除
                    dp[i][j-1] + 1,   // 插入
                    dp[i-1][j-1] + 1  // 替换
                });
            }
        }
    }
    return dp[m][n];
}

时间复杂度：O(mn)
空间复杂度：O(mn)

三、线性DP的优化技巧

3.1 空间优化：滚动数组

当状态只依赖前有限个状态时，可降维存储：

// 最长上升子序列优化（O(n)空间）
int lisOptimized(int a[], int n) {
    vector<int> tail; // 存储潜在LIS的末尾元素
    
    for (int x : a) {
        auto it = lower_bound(tail.begin(), tail.end(), x);
        if (it == tail.end()) {
            tail.push_back(x); // 可扩展LIS
        } else {
            *it = x; // 优化潜在序列
        }
    }
    return tail.size();
}

3.2 时间优化：预处理与剪枝

  • 前缀和/后缀和：用于子数组问题

  • 单调队列/栈：优化滑动窗口类问题

  • 二分查找：将O(n)查找优化为O(logn)

四、练习题库（难度递进）

4.1 基础练习

  1. 爬楼梯问题：每次爬1或2阶，求到n阶的方法数
    状态方程：dp[i] = dp[i-1] + dp[i-2]

  2. 打家劫舍：不能偷相邻房屋，求最大收益
    状态方程：dp[i] = max(dp[i-1], dp[i-2] + nums[i])

  3. 硬币找零：求组成金额的最少硬币数
    状态方程：dp[i] = min(dp[i], dp[i-coin]+1)

4.2 进阶挑战

  1. 最长回文子序列

    dp[i][j] = {
    2 + dp[i+1][j-1],            if s[i]==s[j]
    max(dp[i+1][j], dp[i][j-1]), otherwise
}

  2. 乘积最大子数组

    maxDP[i] = max(nums[i], maxDP[i-1]*nums[i], minDP[i-1]*nums[i])
minDP[i] = min(nums[i], maxDP[i-1]*nums[i], minDP[i-1]*nums[i])

五、总结与学习建议

5.1 线性DP解题四步法

  1. 定义状态：明确 dp[i] 或 dp[i][j] 的含义

  2. 建立方程：找出状态间的递推关系

  3. 初始化：设置边界条件

  4. 确定顺序：选择正确的计算方向

5.2 核心思维训练

  • 分解思想：将大问题拆解为线性子问题

  • 状态设计："以...结尾"是最常用状态定义

  • 方程推导：思考最后一步操作的决策点

动态规划——线性dp
m0_73693552的博客
03-20 5873
线性dp
数学建模——线性规划
m0_51311105的博客
06-21 1万+
目录基本概念模型求解和应用基于求解器的求解方法基于问题的求解方法其他 运筹学的一个重要分支是数学规划，线性规划是数学规划的一个重要的分支。变量称为决策变量，规划的目标称为目标函数，限制条件称为约束条件，s.t.是“受约束于”的意思。建立线性规划模型的一般步骤为：①分析问题，找出决策变量。②找出等式或不等式约束条件。③构造关于决策变量的一个线性函数。线性规划模型的一般形式：或：为目标函数的系数向量，又称为价值向量；为决策向量；为约束方程组的系数矩阵；为约束方程组的常数向量。还有标准型：目标函数为极大型，约束条
动态规划——矩阵链相乘
Wu_L7的博客
04-22 1万+
动态规划之矩阵链相乘
C语言力扣刷题11——打家劫舍1——[线性动态规划]
why1249777255的博客
06-29 1906
C语言刷力扣，打家劫舍1和2，线性动态规划，中等难度题目
运筹学——动态规划
qq_45898993的博客
02-19 6197
目录1. 动态规划的基本概念与建模2. 动态规划问题求解![在这里插入图片描述](https://img-blog.csdnimg.cn/20210219103544190.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1ODk4OTkz,size_16,color_FFFFFF,t_70) 1. 动态规划的基本概念与建模 题1： 某公
动态规划 —— 线性 DP
热门推荐
Alex_McAvoy的博客
08-20 1万+
【概述】 线性动态规划，是较常见的一类动态规划问题，其是在线性结构上进行状态转移，这类问题不像背包问题、区间DP等有固定的模板。 线性动态规划的目标函数为特定变量的线性函数，约束是这些变量的线性不等式或等式，目的是求目标函数的最大值或最小值。 因此，除了少量问题（如：LIS、LCS、LCIS等）有固定的模板外，大部分都要根据实际问题来推导得出答案。 【常见问题】 序列问题：点击这里 最...
强化学习8——动态规划
jinpeng_cumt的博客
09-16 1902
一、基本概念 自适应动态规划（Adaptive Dynamic Programming, ADP）由美国学者Paul J. Werbos在1977年首次提出，是机器学习的重要分支 – 强化学习算法的理论基石。该方法以最优性原理为基础，融合人工智能的先进方法，模拟人通过环境反馈进行学习的思路，有效地解决了动态规划“维数灾”的问题。近年来，自适应动态规划被认为是一种非常接近人脑智能的自学习最优控制方法，并得到了广泛的关注。 二、经典书籍 ...
数学建模——非线性规划
qq_55041016的博客
01-13 2914
基于非线性规划模型解决工业生产的相关问题
线性动态规划——专题
imut zcy,I promise You.
10-16 1507
定义： 线性DP问题的子状态与父状态之间往往相差一个元素，所以子状态通过添加一个增量而转换到父状态。从最小的子问题到原问题，一层一层的状态转移呈现出线性递增的关系，所以称为线性DP。 经典的线性DP问题有最大字段和、最长公共子序列、最长回文子序列、最长不下降（下降）子序列等等。。。 大部分的线性DP都是1维的。 陆续更新线性DP的题。
动态规划——求DAG中最长路径
qq_44502283的博客
04-06 4674
1.问题描述 给定一个有向无环加权图，求图中的最长路径。 该图中的最长距离为14，即2->4->6->2。 2.问题解决 首先我们要对有向无环加权图进行拓扑排序。拓扑排序的意思简要来说就是将图中顶点和边排成一个线性序列，对于<vi, vj>，经拓扑排序后一定满足vi在vj的前面。 拓扑排序的实现方法： 首先找出图中入度为0的点加入拓扑排序后的序列，例子中为S，接着将...
线性规划算法实现——Java版
06-29
1. **线性规划模型**：线性规划问题通常由以下部分组成： - 目标函数：我们需要最大化或最小化的函数，通常表示为`z = c1x1 + c2x2 + ... + cnxn`，其中`ci`是系数，`xi`是决策变量。 - 约束条件：一组线性不等式...
算法：动态规划——线性DP（C++)
m0_52530677的博客
04-14 1682
动态规划概述几类典型问题1.最大连续子序列和2.最长不下降子序列3.最长公共子序列4.最长回文子串5.DAG最长路径6.背包问题总结 博客主要参考书：胡凡《算法笔记》 概述 在我看来动态规划就是将一个问题的最优问题分解为子问题的最优解来获得真正的最优解。动态规划问题当中重要的就是： 状态的转化方程：目标态=F（某一状态）。 有边界状态和其值 使用条件：1.有重复的子问题；2.有最优子结构 几类典型问题 1.最大连续子序列和 题目：给定一个序列：S1，S2，S3…Sn，有i,j使得sum=Si+Si+
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 3232
注意到位置为id，权值为v ,不合法的情况，当且仅当 v = id+k或 v= id-k。dp(i,j,pd)表示考虑到第i号点， 连了j条边，是否有连接i 到 i-1号点。因此，我们把每一个位置和权值抽象成点 ，不合法的情况之间连一条边，可以构成二分图。由此可知，当选了n条边，就恰好n个位置不合法，限制条件是：连的边不能相邻，求出f(m) ，f(m)指代至少有m个位置不合法的方案数。由此总共有2n 个点 k 条链，链与链之间无边 互不干涉。把二分图展开成k条链，进行dp。简单的乘法原理罢了。
【LeetCode 热题100】网格路径类 DP 系列题：不同路径 & 最小路径和（力扣62 / 64 ）（Go语言版）
小韩的博客
06-08 591
本篇介绍了网格路径类动态规划问题，涵盖 LeetCode 第 62 题“不同路径”和第 64 题“最小路径和”。通过定义状态 `dp[i][j]` 和转移方程，分别解决路径计数与最小代价问题。两题均支持一维数组优化空间复杂度。总结对比了两题的异同，并延伸至带障碍路径、三角形路径等问题，帮助读者掌握网格 DP 的核心思路：明确状态、写出转移、找准边界。
加法c++
D_31415926的博客
06-06 399
给定 a 和 b 分别作为被加数和加数，而且限定 a 是 4 位数字，b 是 3 位数字，都是正整数。请你模拟以上加法过程进行输出。如果最后 a+b 的结果是 5 位数，为了保证对齐，需要在被加数和加数前面加空格。只需判断a+b的位数（注：四位数+三位数只可能是四位数或五位数，因为1000+100=1100，9999+999=10998），当a+b为四位数或五位数时输出特定的格式即可。输入两个正整数 a 和 b。
【算法笔记】树套树
fans2306的博客
06-08 1060
在面对二维区间统计问题查询某个一维区间中，大于某个值的数的个数对一个序列同时支持区间查询 + 单点修改我们常用的一维数据结构（如线段树、树状数组）往往显得力不从心。树套树。“树套树”顾名思义，就是一棵树中的每个节点再套一棵树。外层：线段树/树状数组，按照下标维护区间内层：平衡树（如 STLmultiset或手写）维护该区间内的值集合单点修改某个值查询区间中小于/大于某值的数的个数查询区间第kkk小数值（需平衡树）
【2025CVPR】模型融合新范式：PLeaS算法详解（基于排列与最小二乘的模型合并技术）
hasakie的博客
06-08 133
本文深入解析ICLR 2025顶会论文《PLeaS: Merging Models with Permutations and Least Squares》，揭示模型融合领域突破性进展.随着开源模型的爆发式增长，如何高效合并多个专用模型成为关键挑战。传统方法存在三大痛点：而PLeaS创新性地解决了这些难题，实现：PLeaS（Permutations and Least Squares）包含两个核心阶段： 数学本质​： minPi​∈Sdi​​​∥ZiA​−Pi​ZiB​∥F2​ 其中ZiA​,ZiB​是
代码随想录算法训练营第60期第六十二天打卡
最新发布
2401_83782806的博客
06-09 634
今天我们主要讲解了拓扑排序与最短路算法，其实算法实现起来还是有难度，大家一刷的时候大致理解好算法的基本思想就可以了，没必要去深究，我们今天就讲解到这里，我们下次博客再见！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值