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

于 2025-06-12 16:57:05 发布
阅读量1k 收藏 8
点赞数 34
CC 4.0 BY-SA版权
文章标签： 动态规划 代理模式 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/overload100/article/details/148614035

动态规划之背包问题详解

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

一、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. 时间管理调度

动态规划1 —— 01背包详解
我们的征途是星辰大海
09-03 404
从斐波那契数列说起 斐波那契数列（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; }
动态规划入门——详解经典问题零一背包
TechFlow的博客
03-19 729
本文始发于个人公众号：TechFlow，原创不易，求个关注 今天是周三算法与数据结构专题的第12篇文章，动态规划之零一背包问题。 在之前的文章当中，我们一起探讨了二分、贪心、排序和搜索算法，今天我们来看另一个非常经典的算法——动态规划。 在acm-icpc竞赛领域，动态规划是一个非常大的范畴，当中包含了许多变种，而且很多变种难度极大。比如在各种树上和图上以及其他数据结构上做动态规划，这会使得问题...
动态规划之背包问题
m0_64226820的博客
07-26 9368
动态规划的背包问题总结
背包问题详解
yuanlanjun
01-05 350
P01: 01背包问题 题目 有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。 基本思路 这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。 用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是： f[i][v]=max{f[i-1][v],f...
动态规划的详细解析（01背包问题）
追尋ゝ
10-01 2806
算法分析之动态规划详解   先举个例子01背包问题具体例子：假设现有容量15kg的背包，另外有4个物品，分别为a1，a2，a3, a4。物品a1重量为3kg，价值为4；物品a2重量为4kg，价值为5；物品a3重量为5kg，价值为6, a4重6千克，价值为7。将哪些物品放入背包可使得背包中的总价值最大？ 对于这样的问题，如果如上述所涉及的数据比较少的时候，我们通过列举就能算出来，例如，上边的例子
动态规划 背包
yake1965
04-02 720
背包背包 DP01 背包Python VersionPython Version 动态规划 （Dynamic Programming, DP）是一种通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。 背包 DP 有 n 件物品和一个容量为 w 的背包。第 i 件物品的重量是 wiw_iwi​，价值是 viv_ivi​。求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。 背包问题的背景是有一个空间有限的背包（设空间为W）和一堆物品，每个物品都有两个属性，一个是占据的空间 w
动态规划--背包问题
sinat_26230689的博客
07-05 1632
92. Backpack Given n items with size Ai, an integer m denotes the size of a backpack. How full you can fill this backpack? 在n个物品中挑选若干物品装入背包，最多能装多满？ 【样例】 如果有4个物品[2, 3, 5, 7] 如果背包
《动态规划详解——背包问题九讲》PDF版
"《背包问题九讲》是ddengi创作的一份动态规划教程，主要针对NOIP级别的参赛者，详细介绍了背包问题的各种类型及其解法。这份文档旨在通过背包问题探讨动态规划的核心思想，强调读者应注重思考与实践。" 在本教程中...
五大常用算法——动态规划算法详解及经典例题，算法数据结构
04-07
动态规划的应用广泛，尤其在解决最优化问题时，如最短路径问题、背包问题、最长公共子序列等。在实际问题中，例如机器负荷分配问题，动态规划可以帮助确定在不同负荷下生产以最大化五年内的产品总产量。 动态规划的...
什么是01背包问题动态规划以及学习01背包问题动态规划的意义
05-09
### 01背包问题动态规划详解及其学习意义 #### 一、01背包问题概述 01背包问题作为计算机科学领域中的一个经典问题，属于组合优化问题的一种。该问题的基本形式如下：假设我们有一个背包，这个背包的最大承重为W...
动态规划-背包问题详解
2203_75327677的博客
01-19 1979
基于动态规划，对背包问题的四种情况进行详解
【动态规划】背包问题详解
qq_73176808的博客
07-26 1664
本文介绍动态规划中的背包问题
【动态规划】—— 背包问题
forever_bryant的博客
06-26 341
【动态规划】—— 背包问题
【动态规划】背包问题（详细总结，很全）
热门推荐
m0_51370744的博客
10-07 4万+
暴力的解法是指数级别的时间复杂度。进而才需要动态规划的解法来进行优化！背包问题是动态规划（Dynamic Planning） 里的非常重要的一部分,关于几种常见的背包，其关系如下：在解决背包问题的时候，我们通常都是按照如下五部来逐步分析，把这五部都搞透了，算是对动规来理解深入了。二维dp数组01背包，先遍历物品还是先遍历背包都是可以的，且第二层for循环是从小到大遍历一维dp数组01背包，只能先遍历物品再遍历背包容量，且第二层for循环是从大到小遍历。求组合数：外层遍历物品，内层遍历背包。
动态规划（背包问题）
weixin_52725999的博客
08-18 5403
16. 动态规划 16.1 应用场景 背包问题，有一个背包，容量为4磅，现有如下物品 物品 重量 价格 吉他（G） 1 1500 音响（S） 4 3000 电脑（L） 3 2000 要求 讲物品装入背包，在不超出容量的情况下使背包的总价值最大 要求装入的物品不能重复 16.2动态规划算法介绍 动态规划（Dynamic Programming）算法的核心思想是：讲大问题划分为小问题，进行解决，从而进一步获取最优解得处理算法 动态规划算法与分治算法类似，其基本思想也是讲待求解
动态规划 ------ 背包问题
layfolk的博客
05-05 1578
背包问题是动态规划中非常典型的一些题，本篇文章记录总结一下在学习过程中所遇到的一些背包问题。其实主要就是3种,01,完全,多重背包问题，这三种详细一些，认真搞懂了，剩下的就是这三种的变种了，换汤不换药？
动态规划-背包问题
qq_52147470的博客
06-06 2908
算法、背包问题、动态规划
动态规划算法：背包问题
最新发布
2301_79881188的博客
06-02 8446
背包问题概述背包问题概述背包问题 (Knapsack problem) 是⼀种组合优化的NP完全问题。问题可以描述为：给定⼀组物品，每种物品都有⾃⼰的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最⾼。根据物品的个数，分为如下⼏类：•01 背包问题：每个物品只有⼀个•完全背包问题：每个物品有⽆限多个•多重背包问题：每件物品最多有 si 个•混合背包问题：每个物品会有上⾯三种情况......•。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值