【动态规划】背包问题题型及方法归纳

已于 2025-02-02 22:56:09 修改
阅读量7.7k 收藏 53
点赞数 8
分类专栏： 数据结构与算法刷题 # 动态规划 文章标签： 动态规划 算法 图论
于 2023-02-16 15:31:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41094332/article/details/129049548
版权

背包问题的种类

背包问题是在规定背包容量为j的前提下，每个物品对应的体积为v[i]，价值为w[i]，从物品0到物品i中选择物品放入背包中，找出符合某种要求的价值。

（1）背包问题种类

  • 01背包：每种物品只能选择1个。
  • 完全背包：每种物品可以选择无限个。
  • 多重背包：每种物品最多可选s[i]个。
  • 分组背包：有若干个组，每组内有若干个物品，每个物品只能选一次。

（2）递推公式

  • 01背包：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i])
  • 完全背包：dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i])
  • 多重背包：dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i], dp[i - 1][j - 2 * v[i]] + w[i] + ... + dp[i - 1][j - s[i] * v[i]] + s[i] * w[i])
  • 分组背包：dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i][k] + w[i][k], + ... + dp[i - 1][j - s[i]*v[i][k]] + s[i] * w[i][k])

（3）滚动数组遍历顺序：
遵循原则：用到上一层的信息i-1，则从大到小遍历；用到本层的信息i，则从小到大遍历。

  • 01背包：从大到小
  • 完全背包：从小到大。组合问题：先物品，再背包。排列问题：先背包，再物品。
  • 多重背包：在01背包的基础上，用到i-1层信息，从大到小，多一层for循环选物品个数
  • 分组背包：在01背包的基础上，用到i-1层信息，从大到小，多一层for循环选物品个数

（4）初始化问题：

  • 要求恰好装满：dp[i][0] = 0， dp[j] = -∞ （j ≠ 0）
  • 要求恰好装满：dp[i][0] = dp[j] = 0

可以这样理解：初始化的dp数组事实上就是在没有任何物品可以放入背包时的合法状态。如果要求背包恰好装满，那么此时只有容量为0的背包可以在什么也不装且价值为0的情况下被“恰好装满”，其它容量的背包均没有合法的解，属于未定义的状态，应该被赋值为-∞了。如果背包并非必须被装满，那么任何容量的背包都有一个合法解“什么都不装”，这个解的价值为0，所以初始时状态的值也就全部为0了。

（5）题型特点

  • 01背包：已给数组中可用元素固定且每次只能用一次，限制容量固定（可能会存在多重背包容量）。

1、01背包问题

主要分为两部分：状态表示和状态计算。

1. 状态表示dp[i][j]
i是物品个数，j是条件限制。状态表示一般从两个角度考虑，分别为集合和属性。
其中，集合是只考虑前i个物品，不超过j的选法集合。属性值的是数量、最大值、最小值等。当要求的数到达某一个值时，就要求j - v[i]到达那个相应的值时，会更新，这就要求设置好初始值，一般会让dp[i][0]=0或dp[i][0]=1。

2. 状态计算
状态计算主要是集合划分，分为 f(i-1, j) 所有不选第i个物品的方案和所有选择第i个物品的方案，这种方式可保证不遗漏和不重复。

（1）不超过j的条件下，对于所有不选第i个物品的方案
因为是对i从0开始按顺序遍历，因此选择的是从0-i-1中的选择方案。

（2）不超过j的条件下，所有选择第i个物品的方案
此集合包含两个部分，一个是含有第i个物品，另一个是不含第i个物品从0-i-1中选择的方案。含有第i个物品时，表示的是物品i的体积v[i]为唯一的定量。不含第i个物品时，条件就变为j - v[i]，减去了第i个物品的体积，在此条件下，从0-i-1中选，此时会有多种方案，为变量。按我们的目标要求，如果要找最大值，就从多种方案中的一个最大值方案，如果要找最小值，就从多种方案中的最小值方案。两个部分相加，就是我们此方案的结果。

在这里插入图片描述
dp[i][j]二维数组

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;
int dp[N][N];

int main(){

    int n, m;
    int v[N], w[N];
    
    cin >> n >> m;
    for(int i = 1; i <= n; i++)         cin >> v[i] >> w[i];
    
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            // 当前物品重量大于背包容量时，不放该物品
            if(j < v[i])        dp[i][j] = dp[i - 1][j];
            // 当前物品重量小于等于背包容量时，在放该物品后和不放该物品之间选择一个最大价值
            else                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]);
        }
    }
    
    cout << dp[n][m] << endl;
    
    return 0;
}

dp[j]一维滚动数组
将dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i])改为等价式dp[j] = max(dp[j], dp[j - v[i]] + w[i])，遍历顺序改变为从大到小，通常会初始化dp[0]=0或dp[0]=1。

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;
int dp[N];

int main(){

    int n, m;
    int v[N], w[N];
    
    cin >> n >> m;
    for(int i = 1; i <= n; i++)         cin >> v[i] >> w[i];
    
    for(int i = 1; i <= n; i++) {
        // 从后向前遍历，表示装入一个物品后，剩余的可装入容量达到的最大价值
        for(int j = m; j >= v[i]; j--) {
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    
    cout << dp[m] << endl;
    
    
    return 0;
}

151、【动态规划】leetcode ——2. 01背包问题（C++/Python版本）：二维数组+滚动数组

拓展应用：
集合分割问题： 1、2和3。

  1. 152、【动态规划】leetcode ——416. 分割等和子集：滚动数组+二维数组（C++/Python版本）：将重量之和除以2，作为背包容量，找到能让背包中可装物体体积最大的装发，让背包中装入物品的重量等于背包容量。

  2. 【动态规划】leetcode ——1049. 最后一块石头的重量 II：滚动数组（C++/Python版本）：思路与上一题相同，分割成两个数量相近的集合，最后两个集合的综合相减。

  3. 154、【动态规划】leetcode ——494. 目标和：回溯法+动态规划（C++/Python版本）：分割成正数集合和负数集合，背包容量为正数集合大小，找到可组成正数集合大小的组合方式。

  4. 155、【动态规划】leetcode ——474. 一和零：三维数组+二维滚动数组（C++/Python版本）：字符串作为物品，m个0和n个1作为背包容量（具有多重背包）。

2、完全背包问题

与01背包的区别在于同一个物品可以有无限个，对同一个物品可选择多次。

在这里插入图片描述

状态计算时，在dp[i][j]情况下 ，划分集合时01背包只能 划分成两个集合 ，而完全背包可以划分为多个集合（第i个物品选择0个、1个、2个…一直到体积达到或超过j为止的多种方案），其中选择0个时，就相当于在0-i-1中选择的方案dp[i - 1][j]。

递推公式表达式为：
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i], dp[i - 1][j - 2*v[i]] + 2*w[i] + ... + dp[i - 1][j - n*v[i]] + n*w[i])（n*v[i]刚好小于等于j）

现在来进行简化，由上式可知，dp[i][j - v[i]] = max(dp[i - 1][j - v[i]], dp[i - 1][j - 2*v[i]] + w[i] + ... + dp[i - 1][j - n*v[i]] + (n-1)*w[i])，对该式两端加上一个w再联立第一个式子，从而得最终简化式子：

dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i])

dp[i][j]二维数组

#include <iostream>

using namespace std;

const int N = 1010;
int dp[N][N];
int v[N], w[N];
int n, m;

int main(){
    cin >> n >> m;
    for(int i = 1; i <= n; i++)      cin >> v[i] >> w[i];
    
    for(int i = 1; i <= n; i++) {
        for(int j = 1;j <= m; j++) {
            if(v[i] > j)        dp[i][j] = dp[i - 1][j];
            else                dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i]);
        }
    }
    
    cout << dp[n][m] << endl;
    
    return 0;
}

d[j]一维滚动数组
滚动数组的遍历顺序按照从小到大遍历。

#include <iostream>

using namespace std;

const int N = 1010;
int dp[N];
int v[N], w[N];
int n, m;


int main(){
    cin >> n >> m;
    for(int i = 1; i <= n; i++)      cin >> v[i] >> w[i];
    
    for(int i = 1; i <= n; i++) {
        for(int j = v[i]; j <= m; j++) {
            // dp[i][j] = max(dp[i - 1][j], dp[i][j - v[i]] + w[i])
            dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
        }
    }
    
    cout << dp[m] << endl;
    
    return 0;
    
}

156、【动态规划】AcWing ——3. 完全背包问题：二维数组+一维滚动数组（C++/Python版本）

拓展应用：
完全背包中，会牵扯两个不同的问题：组合问题和排列问题。对于组合问题，就是规定一批相同的元素，不同的排列代表同一个结果。而排列问题，就是规定一批相同的元素，不同的排列代表不同的结果。为了实现这两个问题，通常会让组合问题遍历顺序是先遍历物品，再遍历背包，这样子可以让dp只记录某一结果中的一种情形仅被记录。而排列问题遍历顺序是先遍历背包，再遍历物品，这样子可以让dp记录所有的排列出现的情况。

例如，[1, 3]和[3, 1]，在组合问题中只记录了[1, 3]这种情况即可。而在排列问题中，[1, 3]和[3, 1]都被记录了下来。
先遍历物品，再遍历背包，会让某一物品，在各个容量的情况下按物品放入顺序被唯一确定下来放还是不放。
先遍历背包，再遍历物品，会让在不同容量下，都将各个物品从头遍历了一遍，就会得到所有的排列情况。

无顺序要求的题目：

  1. 159、【动态规划】leetcode ——322. 零钱兑换：二维数组+一维滚动数组（C++版本）：注意求最小值的初始化，由于不考虑顺序问题，因此遍历顺序都可以，dp[i][j] = min(dp[i - 1][j], dp[i][j - coins[i]])。

  2. 160、【动态规划】leetcode ——279. 完全平方数：二维数组+一维滚动数组（C++版本）：方式同上，递推公式用上完全平方数形式，dp[i][j] = min(dp[i - 1][j], dp[i][j - i * i] + 1)。

（1）组合问题

数组中元素相同、顺序不同视为同一个结果，组合问题遍历顺序按先物品，再遍历背包。

  1. 158、【动态规划】leetcode ——518. 零钱兑换 II：二维数组+一维滚动数组（C++版本）：零钱可以多次使用不考虑数字顺序位置关系，累加计算dp[i][j] = dp[i - 1][j] + dp[i][j - v[i]]。

  2. 191、【动态规划】AcWing ——AcWing 900. 整数划分：完全背包解法+加减1解法（C++版本）：dp[i][j] = (dp[i - 1][j] + dp[i][j - i])，从1~n中选数，组合成总额和为j的方案个数。

（2）排列问题

数组中元素相同、顺序不同视为不同结果，排列问题遍历顺序按先背包，再遍历物品。最内层再加上一个从0-i再遍历探寻各种情况的for循环。

  1. 158、【动态规划】leetcode ——377. 组合总和 Ⅳ（C++版本）：数字可以多次使用考虑数字顺序位置关系，一维滚动数组累加计算dp[j] += dp[j - v[i]]，二维比较特别sum(dp[i][j], dp[i][j - nums[k])，内层需要从0-i再遍历一次。

  2. 145、【动态规划】leetcode ——70. 爬楼梯：暴力法+动态规划（C++版本）：完全背包解法与题2相同，也是排列问题。

  3. 161、【动态规划】leetcode ——139. 单词拆分：回溯法+动态规划（C++版本）：这个题比较奇特一些，当满足前面的字符可以被组成并且当前单词可以有字典中组成时，为dp[j] = true

3、多重背包问题

多重背包是对每种物品的数量进行限制，dp[i][j]的意思：在第i种物品的个数为规定s[i]个的前提下，背包容量为j，物品体积为v[i]，从物品0到物品i中选择物品，可达到的最大价值。

实现方式是在01背包实现的基础上，遍历时候，在最内层设置一个for循环，寻找从一个都不选到选s[i]个第i个物品时，哪种情况取得最大价值。

dp[i][j]二维数组

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

int n, m;
int dp[N][N];
int v[N], w[N], s[N];


int main() {
    cin >> n >> m;
    
    for(int i = 1; i <= n; i++)         cin >> v[i] >> w[i] >> s[i];
    
    for(int i = 1; i <= n; i++) {
        for(int j = 1; j <= m; j++) {
            // 一个都不选一直到选s[i]个，选择一种最大价值情况
            for(int k = 1; k <= s[i] && j >= k * v[i] ; k++) {
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - k * v[i]] + k * w[i]);
            }
        }
    }
    
    cout << dp[n][m] << endl;
    
    return 0;
    
}

d[j]一维滚动数组

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

int n, m;
int dp[N];
int v[N], w[N], s[N];


int main() {
    cin >> n >> m;
    
    for(int i = 1; i <= n; i++)         cin >> v[i] >> w[i] >> s[i];
    dp[0] = 0;
    
    for(int i = 1; i <= n; i++) {
        for(int j = m; j >= 0; j--) {
            // 一个都不选一直到选s[i]个，选择一种最大价值情况
            for(int k = 0; k <= s[i] && j >= k * v[i] ; k++) {
                dp[j] = max(dp[j], dp[j - k * v[i]] + k * w[i]);
            }
        }
    }
    
    cout << dp[m] << endl;
    
    return 0;
    
}

162、【动态规划】AcWing ——4. 多重背包问题 I（C++/Python版本）

4、分组背包

分组背包问题是在01背包的基础上，多了一个组的概念。有若干个组，每组里面有若干个物品，每个物品只能选择一次，找到在背包容量为j的前提下，从0-i组中选择物品，达到背包里价值最大。

d[j]一维滚动数组

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;
int n, m;
int v[N][N], w[N][N], s[N];
int dp[N];
                    
int main() {
    cin >> n >> m;
    for(int i = 1; i <= n; i++) {
        cin >> s[i];
        for(int j = 0; j < s[i]; j++) {
            cin >> v[i][j] >> w[i][j];
        }
    }
    
    for(int i = 1; i <= n; i++) {                   // 遍历物品
        for(int j = m; j >= 1; j--) {               // 从大到小，遍历背包（使用i-1层信息）
            for(int k = 0; k < s[i]; k++) {         // 遍历每组内的物品个数
                if(j >= v[i][k]) {
                    dp[j] = max(dp[j], dp[j - v[i][k]] + w[i][k]);
                }
            }
        }
    }
    
    cout << dp[m] << endl;
    
    
    
    return 0;
}

166、【动态规划】AcWing ——9. 分组背包问题（C++/Python版本）

算法萌新如何学好动态规划（三）
lucius-liu.cn
12-05 412
本文是「动态规划」系列文章的第三篇，作为「动态规划（二）- 线性 DP」的一个延伸，将主要聚焦于动态规划经典模型 —— 背包问题的讲解。 背包问题属于线性 DP 模型，之所以单独拎出来讲，主要是因为该问题信息量大且十分重要，属于面试中常考且必会的知识，因此我们将其放在本系列的第三篇进行介绍。
识别并应对动态归纳类算法题：深入剖析与实战指南
yonggeit的博客
09-06 191
对于 0/1 背包问题，可以将状态定义为背包容量和物品数量，状态转移方程为：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i])，其中 i 表示物品数量，j 表示背包容量，w[i]表示第 i 个物品的重量，v[i]表示第 i 个物品的价值。这意味着以位置 i 结尾的最大和连续子数组的和等于当前位置的元素 nums[i]或者前一个位置的最大和连续子数组的和加上当前位置的元素 nums[i]，取两者中的较大值。背包问题是另一类常见的动态归纳类算法题。
动态规划之背包问题
Lucas_FC_的博客
04-02 323
背包问题汇集
《背包问题》 动态规划
weixin_34413103的博客
05-28 176
问题描述： 一切都要从一则故事说起。 话说有一哥们去森林里玩发现了一堆宝石，他数了数，一共有n个。 但他身上能装宝石的就只有一个背包，背包的容量为C。这哥们把n个宝石排成一排并编上号： 0,1,2,…,n-1。第i个宝石对应的体积和价值分别为V[i]和W[i] 。排好后这哥们开始思考： 背包总共也就只能装下体积为C的东西，那我要装下哪些宝石才能让我获得最大的利益呢？ 思路...
动态规划--背包问题（C++)
最新发布
Spike_Q的博客
03-24 689
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
【动态规划】—— 背包问题
forever_bryant的博客
06-26 334
【动态规划】—— 背包问题
背包问题分类
思凡
09-02 821
01背包问题 有 n 个物体，重量分别为 wi，价值为 vi，在总重量不超过容量 C 的情况下让总价值最高， 但不允许只取走部分物体，要拿走只能整个拿走。 从01背包开始就涉及到了动态规划的知识，动态规划的本质就是递推。 先打表进行观察： 表中 dp[ i ] [ j ] 表示容量为 j，可以在 0 号物品到 i 号物品中进行任意组合，这种情况下的最大值。 第一行与第一列都不用说，一眼就可以直接得到答案。 剩下的部分怎么进行选择呢？ 比如 dp[2] [4] = 6，我们已经知道了 dp[1] [4] =
动态规划-背包问题
qq_52147470的博客
06-06 2878
算法、背包问题、动态规划
动态规划归纳
qq_41648804的博客
08-15 1020
目录 线性DP 最长递增子序列 最长公共子序列 32. 最长有效括号 背包DP 经典背包问题 常见的动态规划问题可以分为以下几类：线性DP、区间DP、背包DP、树形DP等，当然除此之外，还有状态压缩DP、数位DP、计数型DP、递推型DP、概率型DP、博弈型DP、记忆化搜索等， 线性DP 最长递增子序列 dp[i]表示以nums[i]结尾的子序列的最大长度 则dp[i] = max(dp[j] + 1) for j in [0...i-1] and nums[i] >= nums[
OI动态规划练习集：路径、装箱、数塔与单词统计题解
数塔问题又称为最大路径和问题，是一种应用动态规划求解的二维动态规划问题。问题的描述是在一个数字塔中，要求从塔顶走到塔底，每一步只能走到下一层相邻的数字上，目标是使得经过的数字总和最大。 解决数塔问题的...
背包（算法思想&&经典题型&&例题代码）
CSDN_LIUCHENGYU的博客
06-04 683
背包 背包问题属于动态规划中的一大类，背包问题的解题思路也基本上离不开动态规划。背包问题的类型多，但掌握每一种背包的核心代码并不难，难的是背包问题的变式。虽说背包问题的类型多，但背包问题的变式更多，变式多，难度大，不多见多做多领悟是学不会背包的。网上关于背包的博客有很多，更有著名的、延用十年至今仍然热门的背包九讲，所以在这里有关背包的博客就不写那么细了，主要是领悟背包的思想，注意一些易错的地方就可以了。 0-1背包 最基础的背包，有n个物品，第i个物品的重量为w[i]，价值为v[i]，每个物品只能选0次或1
关于背包问题的九种类型，背包九讲_2.0
11-07
关于背包问题的九种类型，解析很透彻，01背包，多重背包，完全背包，二维背包等等。
背包问题（各种分类）
m0_51666003的博客
12-21 2453
0-1背包，完全背包（硬币找零 硬币数无限制），多重背包（硬币找零 硬币数有限制），分数背包
动态规划·背包问题
m0_70948728的博客
07-10 617
一、01背包 二、完全背包 三、多重背包 四、分组背包
各种背包问题（图文并茂超详解附代码）
weixin_69927885的博客
02-28 3628
有一个固定体积的背包，以及若干具有体积和价值的物品。求装哪几件物品可以使得背包内价值最大。也有背包承受的重量固定，求最大价值之类的，换汤不换药，这里我们以体积和价值作为例子。注意：不一定要装满背包。
背包问题常见的几种类型
m0_51220830的博客
12-19 1116
背包问题的目标函数一般都是最大化放入背包中物品的总价值。 常见类型有： 0-1背包：每个物品只能选一次 完全背包：每个物品可以选择无限次 多重背包：每个物品的最多s[i]次 混合背包：包含三种类型物品：选1次、s[i]次或无限次 分组背包（多选择背包）：一批物品分成n组，每组只能选一件装在背包中。相当于从每组中挑出一个物品组成0-1背包。 多维背包：p种物品放入承重能力不同的m个背包种。 多维多选择背包：n类（每类包含多种物品）物品放入m个有体积或承重差异的背包中。 二维背包：又称二维费用
注意题型 四、考试题型 本门课考试题型原则上包括选择题、填空题、简答题、算法分析
02-19
<think>好的，我现在需要处理用户的问题，他们希望介绍考试题型，包括选择题、填空题、简答题和算法分析题。首先，我要确保自己正确理解每个题型的特点和常见结构，这样才能给出准确的解释。接下来，我需要考虑如何将这些内容组织成清晰的中文回答，让用户容易理解。 首先，选择题部分，要说明通常有单选和多选，考察基础知识和应用能力。可能例子比如时间复杂度或者数据结构的选择，但用户给的例子中没有具体题目，所以不需要举例，但需要解释清楚。然后填空题，通常涉及关键概念、术语或代码补全，需要准确记忆和理解。这部分可能需要代码例子，但用户可能不需要，所以保持简洁。 简答题部分，需要详细阐述概念、区别或步骤，比如哈希表的工作原理或排序算法比较。这部分要强调理解和表达能力。算法分析题则是重点，可能要求分析时间空间复杂度，或者给出算法思路，甚至编写伪代码。这部分需要逻辑性和应用能力，可能需要例子，但用户没给，所以点到为止。 接下来要检查是否有遗漏的题型，用户提到的四个类型已经齐全。需要确认每个部分的描述是否准确，比如算法分析题是否包括伪代码或实际编码，可能需要提到不同学校可能有不同侧重点。还要注意用词是否专业但易懂，比如“时间复杂度”、“空间复杂度”是否要解释，但用户是考试准备，可能已经了解这些术语，所以不需要展开。 然后要考虑结构是否清晰，分点说明每个题型，每个部分用标题和项目符号，但用户可能需要直接的回答，所以可能需要分段加粗标题，但根据用户之前的回答历史，可能使用编号和标题。同时要注意语言流畅，避免重复，确保每个题型的介绍都涵盖考察重点和示例。 最后，检查是否有拼写或语法错误，确保用词准确，比如“伪代码”而不是“伪代码”，确认每个部分的描述符合常见的考试题型结构。确保回答全面，覆盖所有四个题型，并且每个部分的信息准确有用，帮助用户明确考试准备的方向。</think>以下是针对《数据结构》或《算法设计与分析》类课程常见考试题型的介绍，供你参考： --- ### **四、考试题型说明** 1. **选择题** - **题型特点**：通常为单选或多选，考察对基础概念、算法特性、时间/空间复杂度的快速判断。 - 场景应用选择（如哈希冲突的解决方式）。 2. **填空题** - **题型特点**：直接填写关键词、代码片段或计算结果，侧重精准记忆与细节理解。 - **常见考点**： - 关键术语（如“完全二叉树”的定义）； - 代码补全（如二叉树的遍历代码缺失部分）； - 算法关键步骤（如Dijkstra算法的松弛操作）。 3. **简答题** - **题型特点**：需简明阐述概念、对比差异或描述步骤，注重逻辑表达与核心要点。 - **典型问题**： - 解释动态规划与分治法的异同； - 说明AVL树的平衡调整过程； - 列举图的存储方式及优缺点。 4. **算法分析题** - **题型特点**：综合难度较高，需分析算法设计思想、复杂度，或进行伪代码编写。 - **考察重点**： - 手推算法执行过程（如堆排序的建堆步骤）； - 证明算法正确性（如贪心选择性质）； - 设计算法解决特定问题（如用回溯法解0-1背包）。 --- ### **备考建议** - **选择题/填空题**：熟记核心概念，结合代码实例理解细节； - **简答题**：归纳高频问题，结构化记忆（如“定义+特点+举例”）； - **算法分析**：动手推导经典算法（如DFS、快排），总结解题模板。 可根据具体课程大纲调整侧重点，建议结合课后习题与往年真题针对性练习。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

辰阳星宇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值