动态规划3——背包类动态规划详解

最新推荐文章于 2025-10-07 17:15:24 发布
原创 最新推荐文章于 2025-10-07 17:15:24 发布 · 1.8k 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#动态规划 #代理模式 #算法

动态规划之背包问题详解

背包问题是动态规划领域的核心内容，也是算法竞赛和面试中的常考题型。本文系统性地介绍各类背包问题的解题思路、状态转移方程和优化技巧，帮助读者全面掌握这一重要算法范式。

一、01背包问题

问题描述

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。第 i 件物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

核心思想

01背包的核心在于每件物品只有选与不选两种状态，状态转移方程为：

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

代码实现

二维解法（基础）
#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 1005;
int f[MAXN][MAXN];  // f[i][j]表示前i件物品放入容量为j的背包的最大价值
int v[MAXN], w[MAXN]; // 体积和价值

int main() {
    int n, m;
    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 = 0; j <= m; j++) {
            f[i][j] = f[i-1][j]; // 不选第i件物品
            if (j >= v[i]) // 能选第i件物品
                f[i][j] = max(f[i][j], f[i-1][j-v[i]] + w[i]);
        }
    }
    cout << f[n][m];
    return 0;
}
一维优化（空间优化）
#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 1005;
int f[MAXN]; // 优化为一维数组
int v[MAXN], w[MAXN];

int main() {
    int n, m;
    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--) // 逆序遍历避免覆盖
            f[j] = max(f[j], f[j-v[i]] + w[i]);
    
    cout << f[m];
    return 0;
}

关键点

  1. 逆序遍历保证每个物品只被选取一次

  2. 状态转移基于前一个状态的值

  3. 时间复杂度O(NV)，空间复杂度O(V)

二、完全背包问题

问题描述

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

核心思想

与01背包的区别在于物品可以无限次选取，状态转移方程为：

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

代码实现

二维解法
#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 1005;
int f[MAXN][MAXN];
int v[MAXN], w[MAXN];

int main() {
    int n, m;
    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 = 0; j <= m; j++) {
            f[i][j] = f[i-1][j];
            if (j >= v[i])
                f[i][j] = max(f[i][j], f[i][j-v[i]] + w[i]);
        }
    }
    cout << f[n][m];
    return 0;
}
一维优化
#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 1005;
int f[MAXN];
int v[MAXN], w[MAXN];

int main() {
    int n, m;
    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++) // 正序遍历允许重复选取
            f[j] = max(f[j], f[j-v[i]] + w[i]);
    
    cout << f[m];
    return 0;
}

与01背包的区别

  1. 正序遍历允许物品多次选取

  2. 状态转移基于当前行而不是上一行

  3. 时间复杂度仍为O(NV)，但状态转移逻辑不同

三、多重背包问题

问题描述

有 N 种物品和一个容量是 V 的背包。第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。

二进制优化

当物品数量较大时，使用二进制优化将多重背包转化为01背包：

#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 25000; // 1000*log2000 ≈ 22000
int f[MAXN], v[MAXN], w[MAXN];

int main() {
    int n, m, cnt = 0;
    cin >> n >> m;
    
    // 二进制拆分
    for (int i = 1; i <= n; i++) {
        int a, b, s;
        cin >> a >> b >> s;
        int k = 1;
        while (k <= s) {
            cnt++;
            v[cnt] = a * k;
            w[cnt] = b * k;
            s -= k;
            k *= 2;
        }
        if (s > 0) {
            cnt++;
            v[cnt] = a * s;
            w[cnt] = b * s;
        }
    }
    
    // 01背包求解
    for (int i = 1; i <= cnt; i++)
        for (int j = m; j >= v[i]; j--)
            f[j] = max(f[j], f[j-v[i]] + w[i]);
    
    cout << f[m];
    return 0;
}

优化原理

  1. 将数量s拆分为2的幂次之和（1,2,4,...,2^k,s-2^k）

  2. 每个拆分后的物品视为独立的01背包物品

  3. 优化时间复杂度从O(NVS)降为O(NVlogS)

四、分组背包问题

问题描述

给定N组物品和一个容量为V的背包。每组物品有若干个，但在同一组内，最多只能选择一件物品。每件物品有其对应的体积和价值。目标是选择物品放入背包，使得总体积不超过背包容量，且总价值最大。

状态转移

f[i][j] = max(f[i-1][j], max_{1≤k≤s_i}(f[i-1][j-v_{ik}] + w_{ik}))

代码实现

#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 105;
int f[MAXN][MAXN], v[MAXN][MAXN], w[MAXN][MAXN], s[MAXN];

int main() {
    int n, m;
    cin >> n >> m;
    
    for (int i = 1; i <= n; i++) {
        cin >> s[i];
        for (int j = 1; j <= s[i]; j++)
            cin >> v[i][j] >> w[i][j];
    }
    
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j <= m; j++) {
            f[i][j] = f[i-1][j]; // 不选该组任何物品
            for (int k = 1; k <= s[i]; k++) {
                if (j >= v[i][k])
                    f[i][j] = max(f[i][j], f[i-1][j-v[i][k]] + w[i][k]);
            }
        }
    }
    
    cout << f[n][m];
    return 0;
}

优化技巧

  1. 使用一维数组优化空间

  2. 每组内部循环放在最内层

  3. 逆序遍历背包容量

五、二维费用背包问题

问题特点

背包限制条件从单一容量变为两个维度（如重量和体积、金钱和时间等）

潜水员问题

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int MAXM = 85, MAXN = 25;
int f[MAXM][MAXN]; // f[j][k]: 氧气至少j，氮气至少k的最小重量
int O2[MAXN], N2[MAXN], W[MAXN];

int main() {
    int m, n, k;
    cin >> m >> n >> k;
    
    memset(f, 0x3f, sizeof f);
    f[0][0] = 0;
    
    for (int i = 1; i <= k; i++)
        cin >> O2[i] >> N2[i] >> W[i];
    
    for (int i = 1; i <= k; i++) {
        for (int j = m; j >= 0; j--) {
            for (int k = n; k >= 0; k--) {
                int nj = max(0, j - O2[i]);
                int nk = max(0, k - N2[i]);
                f[j][k] = min(f[j][k], f[nj][nk] + W[i]);
            }
        }
    }
    
    cout << f[m][n];
    return 0;
}

宠物小精灵收服

#include <iostream>
#include <algorithm>
using namespace std;

const int MAXM = 505, MAXN = 1005;
int f[MAXN][MAXM]; // f[j][k]: 使用j个球，消耗k体力的最大收服数
int balls[MAXN], damage[MAXM];

int main() {
    int n, m, k;
    cin >> n >> m >> k;
    m--; // 保留1点体力
    
    for (int i = 1; i <= k; i++)
        cin >> balls[i] >> damage[i];
    
    for (int i = 1; i <= k; i++) {
        for (int j = n; j >= balls[i]; j--) {
            for (int k = m; k >= damage[i]; k--) {
                f[j][k] = max(f[j][k], f[j-balls[i]][k-damage[i]] + 1);
            }
        }
    }
    
    int max_catch = f[n][m], min_damage = 0;
    for (int k = 0; k <= m; k++) {
        if (f[n][k] == max_catch) {
            min_damage = k;
            break;
        }
    }
    
    cout << max_catch << " " << m + 1 - min_damage;
    return 0;
}

六、混合背包问题

问题描述

混合背包结合了01背包、完全背包和多重背包，需要根据物品类型选择不同的处理策略。

通用解法

#include <iostream>
#include <algorithm>
using namespace std;

const int MAXM = 205;
int dp[MAXM];

// 01背包处理
void zeroOnePack(int weight, int value, int capacity) {
    for (int j = capacity; j >= weight; j--)
        dp[j] = max(dp[j], dp[j-weight] + value);
}

// 完全背包处理
void completePack(int weight, int value, int capacity) {
    for (int j = weight; j <= capacity; j++)
        dp[j] = max(dp[j], dp[j-weight] + value);
}

// 多重背包处理（二进制优化）
void multiplePack(int weight, int value, int count, int capacity) {
    if (weight * count >= capacity) {
        completePack(weight, value, capacity);
        return;
    }
    
    int k = 1;
    while (k < count) {
        zeroOnePack(k*weight, k*value, capacity);
        count -= k;
        k *= 2;
    }
    zeroOnePack(count*weight, count*value, capacity);
}

int main() {
    int m, n;
    cin >> m >> n;
    
    for (int i = 0; i < n; i++) {
        int w, v, s;
        cin >> w >> v >> s;
        
        if (s == 0) completePack(w, v, m);
        else if (s == 1) zeroOnePack(w, v, m);
        else multiplePack(w, v, s, m);
    }
    
    cout << dp[m];
    return 0;
}

七、有依赖的背包问题

金明的预算方案

#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 32005;
int main_w[65], main_v[65];
int annex_w[65][3], annex_v[65][3];
int f[MAXN];

int main() {
    int n, m;
    cin >> n >> m;
    
    for (int i = 1; i <= m; i++) {
        int v, p, q;
        cin >> v >> p >> q;
        if (!q) {
            main_w[i] = v;
            main_v[i] = v * p;
        } else {
            annex_w[q][0]++;
            annex_w[q][annex_w[q][0]] = v;
            annex_v[q][annex_w[q][0]] = v * p;
        }
    }
    
    for (int i = 1; i <= m; i++) {
        if (!main_w[i]) continue;
        
        for (int j = n; j >= main_w[i]; j--) {
            // 只选主件
            f[j] = max(f[j], f[j-main_w[i]] + main_v[i]);
            
            // 主件+附件1
            if (j >= main_w[i] + annex_w[i][1])
                f[j] = max(f[j], f[j-main_w[i]-annex_w[i][1]] + main_v[i] + annex_v[i][1]);
            
            // 主件+附件2
            if (j >= main_w[i] + annex_w[i][2])
                f[j] = max(f[j], f[j-main_w[i]-annex_w[i][2]] + main_v[i] + annex_v[i][2]);
            
            // 主件+附件1+附件2
            if (j >= main_w[i] + annex_w[i][1] + annex_w[i][2])
                f[j] = max(f[j], f[j-main_w[i]-annex_w[i][1]-annex_w[i][2]] + main_v[i] + annex_v[i][1] + annex_v[i][2]);
        }
    }
    
    cout << f[n];
    return 0;
}

八、总结与拓展

1.背包问题通用解法框架

  1. 定义状态：明确dp数组的含义

  2. 初始化状态：处理边界条件

  3. 状态转移：根据问题类型选择合适的转移方程

  4. 确定结果：找到最终状态对应的解

2.优化技巧对比

问题类型空间优化时间优化特殊技巧
01背包逆序一维无无
完全背包正序一维无无
多重背包一维二进制拆分单调队列优化
分组背包一维无组内循环
二维费用二维无两个限制条件
混合背包一维无分类处理
依赖背包一维无主附件组合

3.实际应用场景

  1. 资源分配问题

  2. 投资组合优化

  3. 生产计划制定

  4. 货物装载优化

  5. 时间管理调度

动态规划算法详解
m0_54615144的博客
07-27 2万+
动态规划算法通常用于求解具有最优性质的问题 基本概念 动态规划过程是：每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划(DP)。 基本思想与策略 基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。...
动态规划1 —— 01背包详解
我们的征途是星辰大海
09-03 519
从斐波那契数列说起 斐波那契数列（Fibonacci sequence），对于n(n>=0),n=0时，f(0)=0; n=1时，f(1)=1;n=2时，f(2)=f(0)+f(1)；n=3时，f(2)=f(1)+f(2)；以此类推…求解f(n)。 最早 ，我们可能在课本上学过，这是个经典的递归问题，于是，能很很快写出递归的代码： public int fib(int N) { if (N == 0) { return 0; }
【动态规划】背包问题（详细总结，很全）
热门推荐
m0_51370744的博客
10-07 4万+
暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！背包问题是动态规划（Dynamic Planning） 里的非常重要的一部分,关于几种常见的背包，其关系如下：在解决背包问题的时候，我们通常都是按照如下五部来逐步分析，把这五部都搞透了，算是对动规来理解深入了。二维dp数组01背包，先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历一维dp数组01背包，只能先遍历物品再遍历背包容量，且第二层for循环是从大到小遍历。求组合数：外层遍历物品，内层遍历背包。
动态规划 - 背包问题
最新发布
Small_entreprene的博客
10-07 1247
摘要： 背包问题是一类经典的组合优化问题，核心目标是在限定总重量内选择物品使总价值最大。根据物品选取方式可分为01背包（每件选一次）、完全背包（无限选取）、多重背包（有限选取）等变种；根据约束条件可分为普通背包和二维费用背包；根据求解目标可分为最优解、方案数等问题。动态规划是主要解法，通过状态转移方程（如01背包的dp[i][j] = max(dp[i-1][j], dp[i-1][j-v[i]]+w[i])）实现，可通过滚动数组优化空间。典型例题包括分割等和子集（LeetCode 416）、目标和（Lee
背包问题详解（含代码）
林一百二十八的博客
11-10 5421
背包背包背包，动态规划啊
算法整理六——动态规划
weixin_45901806的博客
02-23 5491
一、概述 基本思想是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。 动态规划算法的有效性依赖于问题本身所具有的两个重要性质：最优子结构、重叠子问题 1、最优子结构：当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。 2、重叠子问题： 在解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。动态规划算法(自底向上)正是利用了这种子问题的重叠性质，对每一个子问题只解一次，而后将其解保存在一个表格中，在以后尽可能多地利用这些子问题的解。
【动态规划】—— 背包问题
forever_bryant的博客
06-26 364
【动态规划】—— 背包问题
背包问题详解
yuanlanjun
01-05 380
P01: 01背包问题 题目 有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。 基本思路 这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。 用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是： f[i][v]=max{f[i-1][v],f...
《动态规划详解——背包问题九讲》PDF版
"《背包问题九讲》是ddengi创作的一份动态规划教程，主要针对NOIP级别的参赛者，详细介绍了背包问题的各种类型及其解法。这份文档旨在通过背包问题探讨动态规划的核心思想，强调读者应注重思考与实践。" 在本教程中...
动态规划入门——详解经典问题零一背包
TechFlow的博客
03-19 760
本文始发于个人公众号：TechFlow，原创不易，求个关注 今天是周三算法与数据结构专题的第12篇文章，动态规划之零一背包问题。 在之前的文章当中，我们一起探讨了二分、贪心、排序和搜索算法，今天我们来看另一个非常经典的算法——动态规划。 在acm-icpc竞赛领域，动态规划是一个非常大的范畴，当中包含了许多变种，而且很多变种难度极大。比如在各种树上和图上以及其他数据结构上做动态规划，这会使得问题...
五大常用算法——动态规划算法详解及经典例题，算法数据结构
04-07
动态规划的应用广泛，尤其在解决最优化问题时，如最短路径问题、背包问题、最长公共子序列等。在实际问题中，例如机器负荷分配问题，动态规划可以帮助确定在不同负荷下生产以最大化五年内的产品总产量。 动态规划的...
什么是01背包问题动态规划以及学习01背包问题动态规划的意义
05-09
### 01背包问题动态规划详解及其学习意义 #### 一、01背包问题概述 01背包问题作为计算机科学领域中的一个经典问题，属于组合优化问题的一种。该问题的基本形式如下：假设我们有一个背包，这个背包的最大承重为W...
动态规划（背包问题）
2401_87934559的博客
07-28 1265
问题核心：在有限容量的背包中，如何选择物品以获得最大价值” 的问题，其中每个物品通过构建一个 DP 数组，记录 “在特定容量下能获得的最大价值”，逐步推导最优解。设dp[i][c]表示ii-1c。对于第i个物品（索引i-1：最大价值等于前i-1个物品在容量c时的价值，即；（满足v[i-1] ≤ c）：价值为 “前i-1个物品在容量c - [i-1]时的价值” 加上当前物品的价值，即。因此，状态转移方程为：（若v[i-1] ≤ c，否则取前者）。有 N 件物品和一个容量是 V 的背包。
动态规划-背包问题详解
2203_75327677的博客
01-19 2082
基于动态规划，对背包问题的四种情况进行详解
《背包问题》 动态规划
weixin_34413103的博客
05-28 221
问题描述： 一切都要从一则故事说起。 话说有一哥们去森林里玩发现了一堆宝石，他数了数，一共有n个。 但他身上能装宝石的就只有一个背包，背包的容量为C。这哥们把n个宝石排成一排并编上号： 0,1,2,…,n-1。第i个宝石对应的体积和价值分别为V[i]和W[i] 。排好后这哥们开始思考： 背包总共也就只能装下体积为C的东西，那我要装下哪些宝石才能让我获得最大的利益呢？ 思路...
动态规划算法：背包问题
2301_79881188的博客
06-02 8724
背包问题概述背包问题概述背包问题 (Knapsack problem) 是⼀种组合优化的NP完全问题。问题可以描述为：给定⼀组物品，每种物品都有⾃⼰的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最⾼。根据物品的个数，分为如下⼏类：•01 背包问题：每个物品只有⼀个•完全背包问题：每个物品有⽆限多个•多重背包问题：每件物品最多有 si 个•混合背包问题：每个物品会有上⾯三种情况......•。
动态规划的详细解析（01背包问题）
追尋ゝ
10-01 2834
算法分析之动态规划详解   先举个例子01背包问题具体例子：假设现有容量15kg的背包，另外有4个物品，分别为a1，a2，a3, a4。物品a1重量为3kg，价值为4；物品a2重量为4kg，价值为5；物品a3重量为5kg，价值为6, a4重6千克，价值为7。将哪些物品放入背包可使得背包中的总价值最大？ 对于这样的问题，如果如上述所涉及的数据比较少的时候，我们通过列举就能算出来，例如，上边的例子
动态规划 ------ 背包问题
layfolk的博客
05-05 1731
背包问题是动态规划中非常典型的一些题，本篇文章记录总结一下在学习过程中所遇到的一些背包问题。其实主要就是3种,01,完全,多重背包问题，这三种详细一些，认真搞懂了，剩下的就是这三种的变种了，换汤不换药？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值