动态规划入门【思路及易错点解析】

原创 已于 2025-02-28 08:02:27 修改 · 821 阅读 · 21 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#动态规划 #算法

于 2025-02-22 14:29:49 首次发布

动态规划的基本步骤

实际上，很多时候dp可以看作更广义的贪心，大多数情况下记忆化搜索和动态规划也可以相互转换。

选自洛谷题单上的部分动态规划入门题目进行解析

一、采药

P1048 [NOIP 2005 普及组] 采药 - 洛谷

经典的背包问题，剩余时间T，需要处理药品种类M，采用二维数组解法

  1. dp[i][j]的含义是采到第i株药草，还剩时间T，能够获得的总最大价值是多少
  2. dp[i][j]=max(dp[i-1][j],dp[i-1][j-timeCost[i]]+value[i])
  3. 第一行无法递推达到，第一行如果大于等于timeCost[0]就赋值values[0]
  4. 从dp[1][0]遍历到dp[M-1][T]
  5. 略
#include <iostream>
#include<vector>
using namespace std;

int main()
{
    //每一株药草有价值和自身消费,给定一段时间，求能拿到药草价值的最大值
    int T; scanf("%d",&T); //1~1000
    int M; scanf("%d",&M); //1~100
    //二维数组，横轴是药草种类，纵轴是剩余时间
    vector<int>values(M,0);
    vector<int>timeCost(M,0);
    vector<vector<int>> dp(M,vector<int>(T+1,0));

    for(int i=0;i<M;i++)
    {
        scanf("%d",&timeCost[i]);
        scanf("%d",&values[i]);
    }

    for(int i=1;i<=T;i++)
    {
        if(i>=timeCost[0]) dp[0][i]=values[0];
    }

    for(int i=1;i<M;i++)
    {
        for (int j = 1; j <= T; j++)
        {
            if (j < timeCost[i]) {
                dp[i][j] = dp[i - 1][j];
            }
            else
            {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - timeCost[i]] + values[i]);
            }
        }
    }

    printf("%d\n",dp[M-1][T]);
    return 0;
}

二、疯狂的采药

  1. dp[i][j] 是还有j体力值在第i种药草上可以获得的最大价值
  2. 递推公式 dp[i][j]=max(dp[i][j-cost[i]]+value[i],dp[i-1][j]);dp[i][j]=dp[i-1][j]
  3. 初始化，第0行，小于cost[0]的全置[0]大于cost[0]的就除以cost[0]看看个数
  4. 遍历顺序，从第0行到第N-1行
  5. 举例：略

经典的完全背包，用了空间压缩，或者叫滚动背包，和01背包压缩的区别在于遍历的顺序不同，完全背包是正向遍历，01背包反之


#include <vector>
#include <stdio.h>
using namespace std;
//全开long long 就好了
//完全背包压缩和01背包压缩的区别在于遍历的顺序不同
int main()
{
    long long t,n;
    scanf("%lld %lld",&t,&n);
    vector<long long> timeCost(n,0);
    vector<long long> value(n,0);
    vector<long long> dp(t+1,0);

    for(int i=0;i<n;i++)
    {
        scanf("%lld %lld",&timeCost[i],&value[i]);
    }

    for(int i=0;i<=t;i++)
    {
        dp[i]=i/timeCost[0]*value[0];
    }

    for(int i=1;i<n;i++)
    {
        for(int j=0;j<=t;j++)
        {
            if(j<timeCost[i])
            {
                dp[j]=dp[j];
            }
            else
            {
                dp[j]=max(dp[j],dp[j-timeCost[i]]+value[i]);
            }
        }
    }

    printf("%lld\n",dp[t]);
    return 0;
}

三、5倍经验日

P1802 5 倍经验日 - 洛谷s

经典背包问题，注意开long long

  1. dp[i][j]数组的意义是，还有j瓶药水碰到第i个对手的时候，能获得经验的最大值
  2. 递推公式:dp[i][j]=dp[i-1][j]+fail[i] ;  dp[i][j]=d[i-1][j-cost[i]]+win[i];
  3. 初始化，第一行初始化
  4. 遍历顺序，从第0行到第n-1行
  5. 略
//输出的是5s
//如果你第十个点过不了，请检查你的long long
#include <stdio.h>
#include <vector>

using namespace std;

int main()
{
    int n,x;
    scanf("%d %d",&n,&x);
    vector<int> cost(n,0);
    vector<int> win(n,0);
    vector<int> fail(n,0);

    vector<vector<long>>dp(n,vector<long>(x+1,0));
    for(int i=0;i<n;i++)
    {
        scanf("%d",&fail[i]);
        scanf("%d",&win[i]);
        scanf("%d",&cost[i]);
    }
    //dp[i][j] 标识还有j个药物碰到第i个人能获得的最大经验
    for(int j=0;j<=x;j++)
    {
        if(j>=cost[0])
        {
            dp[0][j]=win[0];
        }
        else
        {
            dp[0][j]=fail[0];
        }
    }

    for(int i=1;i<n;i++)
    {
        for(int j=0;j<=x;j++)
        {
            if(j>=cost[i])
            {
                dp[i][j]=max(dp[i-1][j]+fail[i],dp[i-1][j-cost[i]]+win[i]);
            }
            else
            {
                dp[i][j]=dp[i-1][j]+fail[i];
            }
        }
    }
    printf("%lld\n",5*dp[n-1][x]);
}

四、kkksc03考前临时抱佛脚

P2392 kkksc03考前临时抱佛脚 - 洛谷

这题，需要想好怎么dp,然后就是一个经典的01背包

首先对于同一本习题册，两脑并用，所以需要尽量把两个脑袋计算的时间调平来达到最高速率

计算总的时间，把总的时间分成两块；由于题目不一定完全适配这“一半时间”的容器，所以肯定有一个脑袋少一个脑袋多；

我们计算少用那个脑袋最贴近一半时间的情况，这个时候多用的那个脑袋也最贴近一半时间，达到总时间最少的效果。现在看看，是不是经典的01背包问题呢，总时长为j,有k个问题，每个问题的消费是t,价值也是t,开启dp即可。

#include <stdio.h>
#include <vector>
#include <algorithm> 
using namespace std;

int findMinTime(vector<int>& S, int halftime) {
    int k = S.size();
    if (k == 0) return 0; // 避免空数组访问

    vector<vector<int>> dp(k, vector<int>(halftime + 1, 0));

    for (int j = 0; j <= halftime; j++) {
        if (j >= S[0]) {
            dp[0][j] = S[0];
        }
    }

    for (int i = 1; i < k; i++) {
        for (int j = 0; j <= halftime; j++) {
            if (j < S[i]) {
                dp[i][j] = dp[i - 1][j];
            } else {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - S[i]] + S[i]);
            }
        }
    }

    return dp[k - 1][halftime];
}

int main() {
    int s1, s2, s3, s4;
    scanf("%d %d %d %d", &s1, &s2, &s3, &s4);

    vector<vector<int>> S(4);
    int sizes[4] = {s1, s2, s3, s4};
    int ans = 0;

    for (int i = 0; i < 4; i++) {
        int tmpSum = 0;
        S[i].resize(sizes[i]);

        for (int j = 0; j < sizes[i]; j++) {
            scanf("%d", &S[i][j]);
            tmpSum += S[i][j];
        }

        ans += tmpSum - findMinTime(S[i], tmpSum / 2);
    }

    printf("%d", ans);
    return 0;
}

五、小A点菜

P1164 小A点菜 - 洛谷

分析基本和之前类似，经典的01背包

#include <stdio.h>
using namespace std;
#include <vector>
int main()
{
    int N,M; scanf("%d %d",&N,&M);
    vector<int> a(N,0);
    for(int i=0;i<N;i++)
    {
        scanf("%d",&a[i]);
    }
    //其实是01背包
    vector<int> dp(M+1,0);

    // 递推
    for(int i=0;i<N;i++)
    {
        for(int j=M;j>=0;j--)
        {

            if(j<a[i])
            {
                dp[j]=dp[j];
            }
            else if(j>a[i])
            {
                dp[j]=dp[j]+dp[j-a[i]];
            }
            else
            {
                dp[j]=1+dp[j];
            }
        }
    }
    printf("%d",dp[M]);
    return 0;
}

六、摆花

P1077 [NOIP 2012 普及组] 摆花 - 洛谷

  1. dp[i][j]的意义是还有j盆容量的时候想要加入第i种花最多有多少种方案
  2. 递推方法：考虑第i种花放k盆,
    1. if(k==j) dp[i][j]=dp[i][j]+1;
    2. if(k<j) dp[i][j]+=dp[i-1][j-k] 
  3. 让初始化dp[0][0]=0其实不如特判 k==j的时候来的舒服,你非要去理解为什么容量为0，种类为0的时候有1种解决方案吗，感觉不如说在后边遍历的过程中，如果发现j==k,就+1，因为多的只是那唯一一种
  4. 从dp[1][0]遍历到dp[n][m]
  5. 举例略
#include <iostream>
#include <vector>
using namespace std;

const int MOD = 1e6 + 7;

int main() {
    int n, m;
    cin >> n >> m;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }

    vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
    dp[0][0] = 1; // 初始化：前0种花摆0盆有1种方案

    for (int i = 1; i <= n; ++i) { // 遍历每种花
        int max_k = a[i - 1]; // 当前花最多能选的数量
        for (int j = 0; j <= m; ++j) { // 遍历总盆数
            for (int k = 0; k <= max_k && k <= j; ++k) { // 当前花选k盆
                dp[i][j] = (dp[i][j] + dp[i - 1][j - k]) % MOD;
            }
        }
    }

    cout << dp[n][m] % MOD << endl;
    return 0;
}

七、数字三角形

P1216 [IOI 1994] 数字三角形 Number Triangles - 洛谷

有的时候其实写记忆化搜索比之前的更加好写，并且方便记录路径（只需要在递归函数中加入，逻辑更为清晰），这里以一道简单的数字三角线为例，进行讲解

#include <bits/stdc++.h>
using namespace std;

vector<vector<int>> memo; // 备忘录：memo[i][j]表示从(i,j)到底部的最大路径和

int dfs(int i, int j, vector<vector<int>>& triangle) {
    if (i >= triangle.size()  || j >= triangle[i].size()) return 0;
    if (i == triangle.size()-1)  return triangle[i][j];
    if (memo[i][j] != -1) return memo[i][j];
    int left = dfs(i+1, j, triangle);
    int right = dfs(i+1, j+1, triangle);
    return memo[i][j] = triangle[i][j] + max(left, right);
}

int main() {
    int r;
    scanf("%d", &r);
    vector<vector<int>> triangle(r);

    // 输入三角形数据
    for (int i=0; i<r; i++) {
        for (int j=0; j<=i; j++) {
            int k;
            scanf("%d", &k);
            triangle[i].push_back(k);
        }
    }

    // 初始化备忘录
    memo.resize(r);
    for (int i=0; i<r; i++) {
        memo[i].resize(triangle[i].size(), -1);
    }

    // 计算最大和
    int maxSum = dfs(0, 0, triangle);
    printf("%d\n", maxSum);

    return 0;
}

总结

本文选取了七道简单的动态规划入门题，简单梳理了动态规划的一般方法，给出易错点，展示使用记忆化搜索解决相关问题的策略.

NOIP 2009普及组初赛试题及解析
QD_Jason的博客
03-04 912
NOIP 2009普及组初赛试题及解析
CTF 逆向入门实战：7 道经典题目解析与逆向思维培养
qq_33933889的博客
05-14 2187
在CTF竞赛中，逆向工程是一项关键技能，涉及分析二进制文件、反编译代码和破解算法逻辑以提取隐藏的Flag。本文通过解析7道经典逆向题目，涵盖了VB、C#、Python和ELF等多种文件类型，详细介绍了解题思路和工具使用。例如，通过工具如PEID和IDA Pro进行查壳和静态分析，使用Reflector反编译C#程序，以及编写Python脚本进行算法逆向。文章强调了逆向工程的核心技巧，如字符串搜索、数据类型转换和算法逆向的三步骤，并建议新手从简单题目入手，逐步提升逆向能力。通过实践，选手可以掌握逆向工程的精髓
经典动态规划题解
nplplus的博客
09-12 1182
本文通过四道经典动态规划题目解析核心解题思路：1. 泰波那契数（空间优化迭代法）；2. 最小花费爬楼梯（状态转移与边界处理）；3. 三步问题（大数取模技巧）；4. 解码方法（字符串分情况处理）。提炼出DP通用五步法：定义状态→推导递推式→处理边界→空间优化→规避特殊情况，并重点提示零值处理、下标映射、数值溢出等易错点，为动态规划入门提供清晰路径。
【动态规划详解】最大正方形问题的优雅解法与图解分析
Despacito0o的博客
05-16 1050
最大正方形问题要求在一个由 '0' 和 '1' 组成的二维矩阵中，找出只包含 '1' 的最大正方形，并返回其面积。该问题可以通过动态规划高效解决。核心思想是定义 dp[i][j] 为以 (i,j) 为右下角的最大正方形边长，状态转移方程为 dp[i][j] = min(dp[i-1][j], dp[i][j-1], dp[i-1][j-1]) + 1，取左、上、左上三个方向的最小值加1。通过遍历矩阵，逐步填充 dp 数组，最终找到最大边长并计算面积。该算法的时间复杂度为 O(m×n)，空间复杂度可优化至 O
Java基础 - 易错知识点整理（待更新）
qq_33934427的博客
06-28 1661
Java易错知识点整理（待更新）
动态规划算法全阶教程与实战合集
weixin_35750747的博客
09-18 690
动态规划（Dynamic Programming, DP）是一种通过分解问题为子问题，并利用子问题的重叠性与最优子结构性质来高效求解复杂优化问题的方法。其核心在于避免重复计算，将已解决的子问题结果保存下来，后续直接查表复用。设我们有 $ n $ 件物品，编号从 $ 1 $ 到 $ n $，每件物品 $ i $ 具有两个属性：- 重量 $ w_i \in \mathbb{Z}^+ $- 价值 $ v_i \in \mathbb{Z}^+ $
JavaScript入门知识点
qq_51029472的博客
07-24 260
浏览器分成两部分渲染引擎和JS引擎渲染引擎用来解析HTML与CSS，俗称内核，比如chrome浏览器的blink，老版本的webkitJS引擎也称为JS解释器，用来读取网页中JavaScript代码，对其处理后运行，比如chrome浏览器的V8。...
《算法竞赛入门经典（第二版）》 紫书 各章课后习题答案及解析（持续更新）有疑问在评论区提问
2303_79017285的博客
10-24 2788
答案均是本人学习所得，重难点会有解析，仅供参考。 该文章旨在提供一个交流平台，大家可在评论区共同探讨问题。 若有疑问或者错误也可在评论区留言，周末统一回复。 制作不易，感谢支持！
数据结构入门必看！树与二叉树的C++实现全解析
最新发布
2502_93058859的博客
12-21 444
本文是一篇面向初学者的二叉树入门指南，作者结合自身学习经验，用通俗易懂的语言讲解二叉树的核心概念和C++实现方法。文章首先解释了树结构的必要性，将其比作文件系统层级关系；然后拆解专业术语，用"家族树"类比帮助理解；重点介绍了二叉树的链式存储实现，包括节点结构定义、前序创建、三种递归遍历（前序/中序/后序）和层序遍历的代码实现，并强调内存管理的重要性。文中还分享了作者总结的4个学习技巧：多画图、先学递归、动手实践、从简单案例入手。最后提供了完整的测试代码，帮助读者快速上手实践。
2021 CSP-J入门级C++试题解析全攻略
资源摘要信息: "2021 CCF非专业级别软件能力认证第一轮 (CSP-J)入门级 C++B卷试题答案及详细解析" 知识点概述： - CCF非专业级别软件能力认证（CSP-J/S）：是一项面向中国中学生的计算机科学竞赛，旨在评估和提高...
【蓝桥杯算法竞赛实战指南：高频题型解析与代码精讲】深度优先搜索动态规划（DP）单源最短路径
王大师企业官方博客
04-02 1545
蓝桥杯作为国内最具影响力的IT类学科竞赛之一，其算法题以思维深度大、代码实现巧著称。本文深度解析近5年高频算法题型，通过典型例题+代码实现+优化思路的三维解析，助力参赛者快速提升算法实战能力。算法能力的提升需要持续刻意练习学习教程（传送门）1、掌握JAVA入门到进阶知识(持续写作中……2、学会Oracle数据库用法(创作中……3、手把手教你vbs脚本制作(完善中……4、牛逼哄哄的IDEA编程利器(编写中……5、吐血整理的面试技巧(更新中……往期文章。
【CSP-S A卷动态规划解题法】：动态规划技巧，竞赛中的制胜利器
随后，文章通过实战演练，深入分析了从入门到高级不同难度级别的动态规划题目，并提出了有效的解法。本文着重强调了动态规划在CSP-S A卷中的应用，对典型题目进行了细致的分析和算法设计，并通过编码实现、优化和...
【AGC005D】~K Perm Counting（计数抽象成图）
2301_77025310的博客
10-01 3682
注意到位置为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--70. 爬楼梯--简单
2301_80071187的博客
12-20 149
这道题考察爬楼梯问题，每次可以爬1或2个台阶，求爬到n阶的不同方法数。采用动态规划解法，初始化dp数组，dp[0]=1，dp[1]=1。对于i≥2，dp[i]=dp[i-1]+dp[i-2]，即当前台阶的方法数等于前两个台阶方法数之和。最终返回dp[n]即为结果。该解法时间复杂度O(n)，空间复杂度O(n)。
智驾空间智能、物理智能、世界模型相关的最新论文和开源算法链接
Bonaventure的博客
12-16 1029
这些资源涵盖了2025年自动驾驶领域的前沿研究，从空间推理到物理建模和世界模拟，提供了丰富的开源工具和理论框架。建议用户通过链接深入探索论文和代码，以应用于实际项目或进一步研究。如果您需要更详细的解读或特定应用建议，请随时补充信息！
从零开始写算法——链表篇4:删除链表的倒数第 N 个结点 + 两两交换链表中的节点
m0_59624833的博客
12-15 911
hot100链表的两道题详解。
(leetcode) 力扣100 15轮转数组（环状替代）
qq_62235017的博客
12-18 977
我们利用这个过程，首先计算需要多少个从起点走回起点的圈数（count，为数组长度与步数的最大公约数，具体推推导后面会给），然后再遍历每一圈，通过创建一个临时变量（current,next，类似于指针的作用），来存储需要移动的变量将其移动到下一个位置，而下一个位置变为信的需移动变量，直到走完当前圈数。我们可以把数组想象一个圆圈，如果我们每次固定步数前进，肯定会在有限圈数回到出发点，这个过程中，有可能会遍历完数组所有数，有可能遍历有限数。这句话的意思是：在这个游戏中，你启动一次任务，只能覆盖到。
【算法笔记】AC自动机
u012559967的专栏
12-19 718
AC自动机: AC自动机是一种高效的多模式字符串匹配算法，它巧妙地将 Trie树的字典结构与 KMP算法的失配指针思想相结合，能同时在一段文本中查找多个模式串的所有出现位置，广泛应用于敏感词过滤、生物信息学序列分析等领域。在字符串匹配领域，我们会遇到两类问题：单模式匹配：给定一个文本字符串和一个模式字符串，判断模式字符串是否出现在文本字符串中。《【算法笔记】KMP算法》多模式匹配：给定一个文本字符串和多个模式字符串，判断所有模式字符串是否出现在文本字符串中。解决方案：AC自动机算法。
JVM 之 垃圾回收算法及其内部实现原理【垃圾回收的核心问题有哪些？分别怎么解决的？可达性分析解决了什么问题？回收算法有哪些？内部怎么实现的？】
人生快意事，读的好书，觅得良友
12-16 1390
JVM垃圾回收面临的核心问题有哪些？分别怎么解决的？ 可达性分析解决了什么问题？回收算法有哪些？内部怎么实现的？ 根节点枚举、安全点、安全区域、记忆集与卡表、写屏障、并发性可达性分析各自解决了什么问题？怎么协同工作的？ G1中他们是怎么协作的？
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值