动态规划

动态规划精讲
最新推荐文章于 2025-12-04 22:00:44 发布
原创 最新推荐文章于 2025-12-04 22:00:44 发布 · 105 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #动态规划 #leetcode #数据结构 #字符串

动态规划

1 什么是动态规划

动态规划(Dynamic Programming，DP)是一种用来解决一类最优化问题的算法思想。简单来说，动态规划将一个复杂的问题分解成若干个子问题，通过综合子问题的最优解来得到原问题的最优解。

一个问题必须拥有重叠子问题和最优子结构，才能使用动态规划去解决。

  • 重叠子问题
  • 如果一个问题可以被分解成若干个子问题，且这些子问题会重复出现，那么就称这个问题拥有重叠子问题。
  • 动态规划通过记录重叠子问题的解，来使下次碰到相同的子问题时，直接使用之前记录的结果，以此避免大量重复计算。
  • 最优子结构
  • 如果一个问题的最优解可以由其子问题的最优解有效的构造出来，那么称这个问题拥有最优子结构。

状态的无后效性是指，当前状态记录了历史信息，一旦状态确定，就不会再改变，且未来的决策只能在已有的一个或者若干个状态的基础上进行，历史信息只能通过已有的状态去影响未来的决策。

如何设计状态和状态转移方程，才是动态规划的核心，也是最难的地方。

2 动态规划的递归写法

以下是斐波那契数列的递归算法；事实上，这个递归算法会涉及到很多重复的计算，导致算法的实际复杂度会高达O(2^n^)。

int F(int n){
  if (n == 0 || n == 1) return 1;
  else return F(n-1) + F (n-2);
}

为了避免重复计算，可以开一个一维数组，用以保存已经计算过的结果，其中dp[n]记录F(n)的结果，并用dp[n]=-1表示F[n]当前还没有被计算过。此时的算法复杂度为O(n)。

动态归划的递归写法在此处又称作记忆化搜索。

int dp[MAXN];
fill(dp, dp + MAXN - 1, -1);
int F(int n){
  if (n == 0 || n == 1) return 1;    //递归边界
  if (dp[n] != -1) return dp[n];    //已经计算过，直接返回结果，不再重复计算
  else {
    dp[n] = F(n-1) + F(n-2);    //计算F(n),并保存至dp[n]
    return dp[n];
  }
}

3 动态规划的递推写法

数塔问题

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
const int MAXN = 1000;
int f[MAXN][MAXN], dp[MAXN][MAXN];

int main(){
    int n;
    cin >> n;
    //输入数塔中的树
    for (int i = 1; i <= n; i++){
        for (int j = 1; j <= i; j++){
            cin >> f[i][j];
        }
    }
    //边界
    for (int j = 1; j <= n; j++){
        dp[n][j] = f[n][j];
    }
    //状态转移方程(从下往上)
    for (int i = n - 1; i >= 1; i--){
        for (int j = 1; j <= i; j++){
            dp[i][j] = max(dp[i + 1][j], dp[i + 1][j + 1]) + f[i][j];
        }
    }
    printf("%d", dp[1][1]);
    return 0;
}

4 最大连续子序列和

暴力解法时间复杂度为O(n^2^)(枚举左右端点i, j)，动态规划解法时间复杂度为O(n)

边界：dp[0] = a[0]

状态转移方程：dp[i] = max{a[i], dp[i-1] + a[i]}

#include <iostream>
#include <algorithm>
using namespace std;
const int MAXN = 10010;
int a[MAXN], dp[MAXN];

int main(){
    int n;
    cin >> n;
    for (int i = 0; i < n; i++){
        cin >> a[i];
    }
    dp[0] = a[0];
    for (int i = 1; i < n; i++){
        dp[i] = max(dp[i - 1] + a[i], a[i]);
    }
    int k = 0;
    for (int i = 1; i < n; i++){
        if (dp[i] > dp[k]){
            k = i;
        }
    }
    cout << dp[k];
    return 0;
}

练习题：

  • PAT A1007 Maximum Subsequence Sum (25)

5 最长不下降子序列

暴力解法枚举时间复杂度为O(2^n^)，动态规划解法时间复杂度为O(n^2^)

dp[i]表示以a[i]结尾的最长不下降子序列长度

边界：dp[i] = 1 (1<= i <= n)

状态转移方程：dp[i] = max{1, dp[j] + 1} (j = 1, 2, …, i - 1&& a[j] < a[i])

#include <iostream>
#include <algorithm>
using namespace std;
const int MAXN = 1000;
int a[MAXN], dp[MAXN];

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++){
        cin >> a[i];
    }
    int ans = -1;
    for (int i = 1; i <= n; i++){
        dp[i] = 1;
        for (int j = 1; j < i; j++){
            if (a[i] >= a[j] && dp[j] + 1 > dp[i]){
                dp[i] = dp[j] + 1;
            }
        }
        ans = max(ans, dp[i]);
    }
    cout << ans;
    return 0;
}

练习题：

  • PAT A1045 Favorite Color Stripe (30)

6 最长公共子序列

暴力解法时间复杂度O(2^m+n^ x max(m, n)，无法承受数据大的情况。动态规划的时间复杂度O(nm)

用dp[i][j]表示字符串A的i号位和字符串B的j号位之前的LCS长度(下标从1开始)

边界：dp[i][0] = dp[0][j] = 0 (0<= i <= n, 0 <= j <= m)

状态转移方程：

dp[i][j] = dp[i-1][j-1]+1 (if A[i] == B[j])

dp[i][j] = max{dp[i][j-1], dp[i-1][j]} (if A[i] != B[j])

#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
const int MAXN = 110;
int dp[MAXN][MAXN];
int main(){
    string A, B;
    cin >> A >> B;
    //边界
    for (int i = 0; i <= A.size(); i++){
        dp[i][0] = 0;
    }
    for (int j = 0; j <= B.size(); j++){
        dp[0][j] = 0;
    }
    //状态转移方程
    for (int i = 1; i <= A.size(); i++){
        for (int j = 1; j <= B.size(); 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]);
            }
        }
    }
    cout << dp[A.size()][B.size()];
    return 0;
}

7 最长公共子串长度

暴力解法时间复杂度O(n^3^)，动态规划解法时间复杂度O(n^2^)

dp[i][j]表示以str1[i]前一个字符和str2[j]之前一个字符结尾的连续公共子串长度。

边界：

dp[i][j] = 0; (if i = 0或j = 0)

状态转移方程：

dp[i][j] = 0; (if str1[i] != str2[j])

dp[i][j] = dp[i-1][j-1] + 1; (if str1[i] == str2[j])

#include <iostream>
#include <string>
#include <cstdio>
using namespace std;
const int MAXN = 10010;
int dp[MAXN][MAXN];

int main() {
    string str1, str2;
    cin >> str1 >> str2;
    //边界
    for (int i = 0; i < str1.size(); i++){
        dp[i][0] = 0;
    }
    for (int j = 0; j < str2.size(); j++){
        dp[0][j] = 0;
    }
    //状态转移方程
    int max = -1;
    for (int i = 1; i <= str1.size(); i++){
        for (int j = 1; j <= str2.size(); j++){
            if (str1[i - 1] != str2[j - 1]){
                dp[i][j] = 0;
            } else {
                dp[i][j] = dp[i-1][j-1] + 1;
            }
            if (dp[i][j] > max){
                max = dp[i][j];
            }
        }
    }
    cout << max;
    return 0;
}

8 最长回文串

暴力解法时间复杂度O(n^3^)， 动态规划解法时间复杂度O(n^2^)

dp[i][j]表示s[i]到s[j]所表示的子串是不是回文串，如果是，则为1，不是则为0

边界：dp[i][i] = 1, dp[i][i+1] = (S[i] == S[i+1]) ? 1:0

状态转移方程：

dp[i][j] = dp[i+1][j-1] (if s[i] == s[j])

dp[i][j] = 0 (if s[i] != s[j])

#include <iostream>
#include <string>
using namespace std;
const int MAXN = 1000;
int dp[MAXN][MAXN];

int main(){
    string s;
    cin >> s;
    int ans = 1;
  //边界
    for (int i = 0; i < s.size(); i++){
        dp[i][i] = 1;
        if (i < s.size() - 1){
            if (s[i] == s[i+1]){
                dp[i][i+1] = 1;
                ans = 2;
            }
        }
    }
  //状态转移方程
    for (int L = 3; L < s.size(); L++){
        for (int i = 0; i + L - 1 < s.size(); i++){
            int j = i + L - 1;
            if (s[i] == s[j] && dp[i+1][j-1] == 1){
                dp[i][j] = 1;
                ans = L;
            }
        }
    }
    cout << ans;
    return 0;
}

9 DAG最长路

int DP(int i){
  if (dp[i] > 0) return dp[i];
  for (int i = 0; j < n; j++){
    if(G[i][j] != INF){
      int temp = DP(j) + G[i][j];
      if (temp > dp[i]) {
        dp[i] = temp;
        choice[i] = j;
      }
    }
  }
  return dp[i];
}

void printPath(int i) {
  printf("%d", i);
  while (choice[i]!=-1){
    i = choice[i];
    printf("->%d", i);
  }
}

10 背包问题

10.1 01背包问题

问题描述：有n件物品，每件物品的重量为w[i]，价值为c[i]。现有一个容量为V的背包，问如何选取物品放入背包，使得背包内物品的总价值最大。其中每种物品都只有一件。

用二维数组存储(时间和空间复杂度都是O(nV))：

dp[i][v]表示前i件物品放入容量为v的背包中所能获得的最大价值。

边界：dp[0][v] = 0 (0<=v<=V)

状态转移方程：dp[i][v] = max{dp[i-1][v], dp[i-1][v - w[i]] + w[i]} (1<=i<=n, w[i]<=v<=V)

#include <iostream>
using namespace std;
const int MAXN = 100;
int dp[MAXN][MAXN], wei[MAXN], val[MAXN];

int main() {
    int n, V;
    cin >> n >> V;
    for (int i = 1; i <= n; i++) cin >> wei[i];
    for (int i = 1; i <= n; i++) cin >> val[i];
  //边界
  for (int i = 0; i <= n; i++){
    dp[i][0] = 0;
  }
  for (int v = 0; v <= V; v++){
    dp[0][v] = 0;
  }
  //状态转移函数
    for (int i = 1; i <= n; i++){
        for (int v = 1; v <= V; v++){
            if (wei[i] > v) dp[i][v] = dp[i-1][v];
            else dp[i][v] = max(dp[i-1][v], dp[i-1][v-wei[i]] + val[i]);
        }
    }
    for (int i = 0; i <= n; i++){
        for (int j = 0; j <= V; j++){
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
    cout << dp[n][V];
    return 0;
}

用一维数组存储，时间复杂度是O(nV)，空间复杂度是O(V)

边界：dp[v] = 0 (0<=v<=V)

状态转移方程：dp[v]=max(dp[v], dp[v-w[j]]+c[i]) (v逆序，从V到0)

#include <iostream>
using namespace std;
const int MAXN = 100;
int wei[MAXN], val[MAXN];

int main() {
    int n, V;
    cin >> n >> V;
    for (int i = 1; i <= n; i++) cin >> wei[i];
    for (int i = 1; i <= n; i++) cin >> val[i];
    //边界
    int dp[MAXN];
    for (int v = 0; v <= V; v++){
        dp[v] = 0;
    }
    //状态转移函数
    for (int i = 1; i <= n; i++){
    //注意：一定要从后往前遍历，不然的话会出错
        for (int v = V; v >= wei[i]; v--){
            dp[v] = max(dp[v], dp[v - wei[i]] + val[i]);
        }
    }

    for (int i = 1; i <= V; i++){
            cout << dp[i] << " ";
    }
    cout << dp[V];
    return 0;
}
10.2 完全背包问题

问题描述：有n种物品，每种物品的单件重量为w[i]，价值为c[i]。现有一个容量为V的背包，问如何选取物品放入背包，使得背包内物品的总价值最大。其中每种物品都有无穷件。

二维：

边界：dp[0][v] = 0

状态转移方程：dp[i][v] = max{dp[i-1][v], dp[i][v - w[i]] + w[i]} (1<=i<=n, w[i]<=v<=V)

一维：

边界：dp[v] = 0 (0<=v<=V)

状态转移方程：dp[v]=max(dp[v], dp[v-w[j]]+c[i]) (v顺序，从wei[i]到V)

//边界
for (int v = 0; v <= V; v++){
  dp[v] = 0;
}
//状态转移函数
for (int i = 1; i <= n; i++){
  //从前往后
  for (int v = wei[i]; v < V; v--){
    dp[v] = max(dp[v], dp[v - wei[i]] + val[i]);
  }
}
直击高频编程考点：动态规划经典算法题总结
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
04-20 4万+
动态规划基本理解分析以及应用举例，同时给出高频笔试考题解法分析和代码展示验证（最大子序和、最长上升子序列、最长公共子序列、最大子数组乘积、分割整数的最大乘积、最长有效括号、不同路径、最小路径和、最大矩形、0-1背包问题、编辑距离、单词拆分、爬楼梯、打家劫舍、强盗抢劫环形街区、股票买卖问题、最佳买卖股票时机含冷冻期、找零钱的最少硬币数、从起点到终点的最小路径数等）
智选球员：运用动态规划提升棒球队的签约效益
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
11-01 7万+
动态规划：签约棒球自由球员 我们定义了一个二维数组 dp，其中 dp[i][j] 表示在考虑前 i 个位置且预算不超过 j 时的最大总VORP值。通过状态转移方程更新 dp 数组，不选择当前位置球员的情况与选择当前位置球员的情况进行比较，选择VORP值更高的方案。最终通过回溯 dp 数组，确定具体选择的球员。 时间复杂度为 O(N×X×P)，其中 N是位置数量，X是预算，P 是每个位置上球员的平均数量。空间复杂度为 O(N×X)，主要用于存储 dp 数组和选择标记数组 chosen。
详解动态规划
如无必要，勿增实体。
10-08 1978
在动态规划中，有效地定义阶段和状态变量是关键步骤之一。以下是详细的解释：动态规划中的阶段是指将问题的过程按照时间或空间特征分解成若干互相联系的阶段，以便按次序求解每个阶段的问题。阶段的划分通常基于问题的时间或空间特征，这样可以更方便地将问题转化为多阶段决策问题。常用字母k表示阶段变量，如第k阶段。状态是指在每个阶段开始时所处的客观条件，通常用变量表示。例如，在第k阶段的状态变量常用 sk 表示。状态变量描述了在某一阶段开始时的各种可能情况，这些情况决定了该阶段的决策和后续状态。
动态规划详解
Meiko记录
10-27 6万+
什么是动态规划？ 动态规划（英语：Dynamic programming，简称 DP），是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。 dynamic programming is a method for solving a complex problem by breaking it down into a collection of simpler su...
动态规划算法
Allence的博客
04-08 2万+
一、动态规划算法思想 动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，
【动态规划】01背包问题（通俗易懂，超基础讲解）
热门推荐
Yngz_Miao的博客
08-24 45万+
问题描述 有n个物品，它们有各自的体积和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？ 为方便讲解和理解，下面讲述的例子均先用具体的数字代入，即：eg：number＝4，capacity＝8 i（物品编号） 1 2 3 4 w（体积） 2 3 4 5 v（价值） 3 4 5 6 总...
动态规划算法：背包问题
2301_79881188的博客
06-02 8729
背包问题概述背包问题概述背包问题 (Knapsack problem) 是⼀种组合优化的NP完全问题。问题可以描述为：给定⼀组物品，每种物品都有⾃⼰的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最⾼。根据物品的个数，分为如下⼏类：•01 背包问题：每个物品只有⼀个•完全背包问题：每个物品有⽆限多个•多重背包问题：每件物品最多有 si 个•混合背包问题：每个物品会有上⾯三种情况......•。
动态规划算法思想讲解
总裁余（余登武）博客
12-26 2099
动态规划（Dynamic Programming，简称DP）是一种解决问题的算法思想，它将一个大问题拆分成多个相互重叠的子问题，并且通过解决这些子问题来求解原始问题。
动态规划有哪些经典题目？
Good_tea_h的博客
07-25 1701
设rn为长度为n的钢条能获得的最大收益，则rn就是我们要找的最优解。
算法之动态规划
一名在校大三学习JAVA
07-14 9543
目录什么是动态规划 概念动态规划的特点动态规划的写法适用的场景何时使用动态规划核心套路区别 斐波那契理解动态规划 换零钱问题 区别 分治和动态规划 贪心和动态规划
精选资源
会议安排（贪心算法和动态规划） 贪心算法和动态规划.pdf
04-08
会议安排（贪心算法和动态规划） 会议安排问题是计算机科学中的一种经典问题，目的是在一系列活动中选择尽可能多的活动，使得每个活动的结束时间不早于下一个活动的开始时间。这个问题可以使用贪心算法和动态规划两...
精选资源
代码 随机动态规划的实例的matlab代码
06-04
代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的matlab代码代码 随机动态规划的实例的...
动态规划解决TSP问题用动态规划算法求解TSP，数据为Solomon数据集的c101文件读取，可视化路径图，用图展示每次迭代的最
10-22
动态规划是一种解决问题的有效方法，尤其在处理具有重叠子问题和最优子结构的复杂问题时。旅行商问题（Traveling Salesman Problem, TSP）是一个经典的组合优化问题，它的目标是找到一个城市的最短可能路线，使得...
欧几里得距离算法-相似度
weixin_45609702的博客
12-04 145
本文介绍了一个计算欧几里得距离的Java方法。该方法接收两个Double数组作为输入，通过计算对应元素差值的平方和再开方，返回两个数组之间的欧几里得距离值。当输入数组长度不一致时，方法会返回0作为默认值。欧几里得距离算法常用于比较两个数组之间的相似度，是数据分析和机器学习中的基础距离度量方法。
【模式识别与机器学习（8）】主要算法与技术（下篇：高级模型与集成方法）之 元学习与集成方法：组合多个学习器来提高整体性能
hiliang521的博客
12-02 784
【模式识别与机器学习（8）】主要算法与技术（下篇：高级模型与集成方法）之 元学习
Leetcode 68 搜索插入位置 | 寻找比目标字母大的最小字母
im_AMBER的博客
12-04 722
你的错误逻辑正确逻辑找到 target 时返回 mid-1找到 target 时，继续向右查找（因为需要「大于」target 的最小字符）target <letters [mid] 时，mid 是候选，需保留，right=mid（左闭右开）或不立即排除 mid循环结束直接返回 letters [0]循环结束后，先判断 left 是否越界：越界则返回 letters [0]，否则返回 letters [left]初始right的取值与「越界判断」不匹配；
dfs|mask^翻转
一个人知道自己为什么而活，他就能够接收任何一种生活
11-30 164
注意到：灯泡状态周期是6。
2025年全国大学生统计科学与算法编程挑战赛——算法赛道（一）
qq_73044452的博客
12-01 290
摘要：本文包含三个编程问题的解决方案。1) 贪吃蛇问题：通过解析移动指令计算蛇最终所在格子的编号；2) 经济小鱼问题：计算前两局存钱、后两局花钱，最终剩余指定金币的方案数；3) 小理吃甜食问题：模拟多轮糖果挑选过程，计算小理获得的最大总糖果值。每个问题都给出了完整的C++实现代码，涉及字符串处理、数学计算和模拟算法等技术。
【剑斩OFFER】算法的暴力美学——数青蛙
最新发布
就业知识博客
12-04 249
力扣1419题：数青蛙
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值