背包问题

已于 2024-04-29 16:19:54 修改
阅读量220 收藏
点赞数
分类专栏： # 动态规划 # 回溯思想 # 分支限界 文章标签： 算法 动态规划 背包问题 回溯思想 分支限界
于 2019-10-31 17:34:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_fearless_engineer/article/details/102822089
版权

文章目录

概述

  背包问题已经被研究了超过一个世纪，是动态规划中的经典问题，也是理解动态规划思想的重要工具。背包问题可以被抽象解释为：给出一个特定体积（重量）容量的背包，再分别给出多个物品的体积（重量）和价值，求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。

0/1背包问题

问题描述

  有体积容量为 M M M的背包和 N N N件物品，第 i ( 0 ≤ i < N ) i(0\leq i < N) i(0≤i<N)件物品的体积为 w w w、价值为 c c c，求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。

输入格式

  每个测试包含一个测试用例，第一行分别给出背包的体积容量 M M M和物品的件数 N N N，接下来有 N N N行数据，每行分别给出第 i i i件物品的体积 w w w和价值 c c c。

输出格式

  输出一行数据，在此行内给出背包内物品的价值总和的最大值。

输入样例

200 8
79 83
58 14
86 54
11 79
28 72
62 52
15 48
68 62

输出样例

334

动态规划

解题思路

  需要解决的根本问题就是需不需要把当前物品放入背包，所以被称为0/1背包问题。
  我们暂且将最终得到的结果称为最优背包，最终的最优背包可以看成是比其体积容量小的最优背包和一件物品组合而成。由于比其容量小的最优背包有多种，物品有多种，所以它们之间的组合方式也有很多种，我们只需要在多种组合方式种找到价值最大的组合方式。我们求出最优背包就能求出比其体积容量更大的最优背包，而这也就满足了最优子结构性质，背包问题也就可以通过动态规划解决。
  在小体积容量最优背包与物品组合的过程中需要注意不能将最优背包内已经含有的物品再次与最优背包进行组合。
  根据以上的思想就能得到动态规划的转移方程：
i for 0 to N − 1 j for m to w [ i ] f [ j ] = max ⁡ ( f [ j − w [ i ] ] + c [ i ] , f [ j ] ) i \quad \textrm{for} \quad 0 \quad \textrm{to} \quad N-1 \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \\ j \quad \textrm{for} \quad m \quad \textrm{to} \quad w[i] \quad \quad \quad \quad \quad \quad \quad \quad \\ f[j] = \max\left(f[j-w[i]]+c[i],f[j]\right) ifor0toN−1jformtow[i]f[j]=max(f[j−w[i]]+c[i],f[j])
  其中 f [ j ] f[j] f[j]表示体积容量为 j j j的最优背包的价值， w [ i ] w[i] w[i]表示第 i i i件物品的体积， c [ i ] c[i] c[i]表示第 i i i件物品的价值， m m m表示背包的体积容量。

测试代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;
int main(){
    size_t m,n;
    cin >> m >> n;///输入背包的体积容量和物品件数
    vector<size_t> w(n);
    vector<size_t> c(n);
    for(size_t i=0;i<n;i++){
        cin >> w[i] >> c[i];///输入每件物品的体积和价值
    }
    vector<size_t> f(m+1,0);///申请内存空间，将各体积容量的背包初始化价值为0
    for(size_t i=0;i<n;i++){///枚举出各件物品
        for(size_t j=m;j>=w[i];j--){///利用小体积容量的最优背包求大体积容量的最优背包
            f[j] = max(f[j-w[i]]+c[i],f[j]);///状态转移方程
        }
    }///第一重循环枚举出各件物品，第二重循环枚举出各体积容量的最优背包，转移方程找出最佳的物品和最优背包组合
    cout << f[m] << endl;
    return 0;
}

回溯思想

解题思路

测试代码

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
struct Stone{
    size_t weight;
    size_t price;
    float purity;
    Stone(size_t weight,size_t price){
        this->weight = weight;
        this->price = price;
        this->purity = (float)price/weight;
    }
    inline bool operator<(Stone &other)const{
        return this->purity<other.purity;
    }
};
class KnapProblem{
    size_t capacity;
    size_t number;
    vector<Stone> stones;
    size_t weight;
    size_t price;
    size_t maximum;
    vector<bool> content;
public:
    KnapProblem(){
        cin >> this->capacity >> this->number;
        this->content.resize(number,false);
        for(size_t i=0;i<this->number;i++){
            size_t weight,price;
            cin >> weight >> price;
            this->stones.push_back(Stone(weight,price));
        }
        sort(this->stones.rbegin(),this->stones.rend());
        this->weight = 0;
        this->price = 0;
        this->maximum = 0;
    }
    bool bound(size_t index){
        size_t surplus = this->capacity-this->weight;
        size_t prediction = this->price;
        while(++index<this->number&&this->stones[index].weight<=surplus){
            surplus -= this->stones[index].weight;
            prediction += this->stones[index].price;
        }
        if(index<this->number){
            prediction += surplus*this->stones[index].purity;
        }
        if(prediction>this->maximum){
            return true;
        }
        return false;
    }
    void backtrack(size_t index){
        if(index==this->number){
            this->maximum = this->price;
        }else{
            if(this->weight+this->stones[index].weight<=this->capacity){
                this->weight += this->stones[index].weight;
                this->price += this->stones[index].price;
                this->content[index] = true;
                backtrack(index+1);
                this->weight -= this->stones[index].weight;
                this->price -= this->stones[index].price;
            }
            if(bound(index)){
                this->content[index] = false;
                backtrack(index+1);
            }
        }
    }
    void print(){
        cout << this->maximum << endl;
        for(size_t i=0;i<this->number;i++){
            if(this->content[i]){
                cout << this->stones[i].weight << ' ' << this->stones[i].price << endl;
            }
        }
    }
};
int main(){
    KnapProblem kp;
    kp.backtrack(0);
    kp.print();
    return 0;
}

分支限界

解题思路

测试代码

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
struct Stone{
    size_t weight;
    size_t price;
    float purity;
    Stone(size_t weight,size_t price){
        this->weight = weight;
        this->price = price;
        this->purity = (float)price/weight;
    }
    inline bool operator<(Stone &other)const{
        return this->purity<other.purity;
    }
};
struct Knap{
    size_t weight;
    size_t price;
    size_t index;
    size_t prediction;
    Knap *parent;
    Knap(){
        this->weight = 0;
        this->price = 0;
        this->index = 0;
        this->parent = nullptr;
    }
    Knap(Knap *parent){
        this->weight = parent->weight;
        this->price = parent->price;
        this->index = parent->index+1;
        this->parent = parent;
    }
    Knap(Knap *parent,Stone &stone){
        this->weight = parent->weight+stone.weight;
        this->price = parent->price+stone.price;
        this->index = parent->index+1;
        this->parent = parent;
    }
};
struct KnapPointerCompare{
    inline bool operator()(const Knap *left,const Knap *right)const{
        return left->prediction<right->prediction;
    }
};
class KnapProblem{
    size_t capacity;
    size_t number;
    vector<Stone> stones;
    priority_queue<Knap *,vector<Knap *>,KnapPointerCompare> open;
    vector<Knap *> closed;
public:
    KnapProblem(){
        cin >> this->capacity >> this->number;
        for(size_t i=0;i<this->number;i++){
            size_t weight,price;
            cin >> weight >> price;
            this->stones.push_back(Stone(weight,price));
        }
        sort(this->stones.rbegin(),this->stones.rend());
    }
    void predict(Knap *knap){
        size_t surplus = this->capacity-knap->weight;
        size_t prediction = knap->price;
        size_t index = knap->index;
        while(index<this->number&&this->stones[index].weight<=surplus){
            surplus -= this->stones[index].weight;
            prediction += this->stones[index].price;
            index++;
        }
        if(index<this->number){
            prediction += surplus*this->stones[index].purity;
        }
        knap->prediction = prediction;
    }
    Knap *branchAndBound(){
        Knap *parent,*child;
        parent = new Knap();
        predict(parent);
        this->open.push(parent);
        while(!this->open.empty()){
            parent = this->open.top();
            this->open.pop();
            this->closed.push_back(parent);
            if(parent->index==this->number){
                return parent;
            }else{
                if(parent->weight+this->stones[parent->index].weight<=this->capacity){
                    child = new Knap(parent,this->stones[parent->index]);
                    predict(child);
                    this->open.push(child);
                }
                child = new Knap(parent);
                predict(child);
                this->open.push(child);
            }
        }
        return nullptr;
    }
    ~KnapProblem(){
        while(!this->open.empty()){
            delete this->open.top();
            this->open.pop();
        }
        for(Knap *knap:this->closed){
            delete knap;
        }
    }
    void print(Knap *child){
        cout << child->price << endl;
        for(Knap *parent=child->parent;parent;child=parent,parent=child->parent){
            if(child->weight-parent->weight){
                cout << child->weight-parent->weight << ' ' << child->price-parent->price << endl;
            }
        }
    }
};
int main(){
    KnapProblem kp;
    kp.print(kp.branchAndBound());
    return 0;
}

完全背包问题

问题描述

  有体积容量为 M M M的背包和 N N N种物品，第 i ( 0 ≤ i < N ) i(0\leq i < N) i(0≤i<N)种物品的体积为 w w w、价值为 c c c，每种物品的数量不限，求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。

输入格式

  每个测试包含一个测试用例，第一行分别给出背包的体积容量 M M M和物品的种数 N N N，接下来有 N N N行数据，每行分别给出第 i i i种物品的体积 w w w和价值 c c c。

输出格式

  输出一行数据，在此行内给出背包内物品的价值总和的最大值。

输入样例

200 8
79 83
58 14
86 54
11 79
28 72
62 52
15 48
68 62

输出样例

1422

解题思路

  在0/1背包问题中不可以将最优背包内已经含有的物品再次与最优背包进行组合，而在完全背包问题中，由于每种物品的数量没有限制，需要将最优背包内已含有的物品再次与最优背包进行组合。也就是只需要在0/1背包问题的代码基础上将枚举最优背包的顺序进行翻转。
  根据以上的思想就能得到动态规划的转移方程：
i for 0 to N − 1 j for w [ i ] to m f [ j ] = max ⁡ ( f [ j − w [ i ] ] + c [ i ] , f [ j ] ) i \quad \textrm{for} \quad 0 \quad \textrm{to} \quad N-1 \quad \quad \quad \quad \quad \quad \quad \quad \quad \quad \\ j \quad \textrm{for} \quad w[i] \quad \textrm{to} \quad m \quad \quad \quad \quad \quad \quad \quad \quad \\ f[j] = \max\left(f[j-w[i]]+c[i],f[j]\right) ifor0toN−1jforw[i]tomf[j]=max(f[j−w[i]]+c[i],f[j])
  其中 f [ j ] f[j] f[j]表示体积容量为 j j j的最优背包的价值， w [ i ] w[i] w[i]表示第 i i i件物品的体积， c [ i ] c[i] c[i]表示第 i i i件物品的价值， m m m表示背包的体积容量。

测试代码

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
int main(){
    size_t m,n;
    cin >> m >> n;///输入背包的体积容量和物品种类数
    vector<size_t> w(n);
    vector<size_t> c(n);
    for(size_t i=0;i<n;i++){
        cin >> w[i] >> c[i];///输入每种物品的体积和价值
    }
    vector<size_t> f(m+1,0);///申请内存空间，将各体积容量的背包初始化价值为0
    for(size_t i=0;i<n;i++){///枚举出各种物品
        for(size_t j=w[i];j<=m;j++){///利用小体积容量的最优背包求大体积容量的最优背包
            f[j] = max(f[j-w[i]]+c[i],f[j]);///状态转移方程
        }
    }///第一重循环枚举出各种物品，第二重循环枚举出各体积容量的最优背包，转移方程找出最佳的物品和最优背包组合
    cout << f[m] << endl;
    return 0;
}

多重背包问题

问题描述

  有体积容量为 M M M的背包和 N N N种物品，第 i ( 0 ≤ i < N ) i(0\leq i < N) i(0≤i<N)件物品的体积为 w w w、价值为 c c c，数量为 q q q，求解将哪些物品装入背包可使这些物品的重量总和不超过背包容量，且价值总和最大。

输入格式

  每个测试包含一个测试用例，第一行分别给出背包的体积容量 M M M和物品的件数 N N N，接下来有 N N N行数据，每行分别给出第 i i i种物品的体积 w w w、价值 c c c和数量 q q q。

输出格式

  输出一行数据，在此行内给出背包内物品的价值总和的最大值。

输入样例

200 8
79 83 2
58 14 3
86 54 5
11 79 1
28 72 8
62 52 4
15 48 10
68 62 9

输出样例

631

解题思路

  了解了0/1背包问题后，最朴素的想法就是将每件物品全部当作独立的个体，不关心它的种类，然后运用0/1背包解决问题。根据以上思路，问题就转换成了 ∑ i = 0 N − 1 q i \sum_{i=0}^{N-1}q_i ∑i=0N−1​qi​（ q i q_i qi​为第 i i i种物品的件数）件物品的0/1背包问题。
  忽略物品的种类无疑是对已知条件的一种浪费，可以对种类加以利用来减少算法的时间复杂度。我们可以对同一种类的物品进行内部合并，将多件物品合并成一件物品，这样就可以减少物品的总数量，以降低算法的时间复杂度。但是我们需要找到一种恰当的合并方法，假如某类物品有13件，合并后的物品之间进行组合要可以表示1到13件原物品。
  根据二进制思想，二进制数可以表示任意的十进制正整数。我们可以把件数拆分出几个2的指数次幂，这样就可以表示任意的件数。任何整数都可以表示成：
Q = ( ∑ i = 0 ⌊ log ⁡ 2 ( Q + 1 ) ⌋ − 1 2 i ) + R Q=\left(\sum_{i=0}^{\lfloor\log_2(Q+1)\rfloor-1}2^i\right)+R Q= ​i=0∑⌊log2​(Q+1)⌋−1​2i ​+R
  例如13就可以划分成1、2、4和6，1、2、4为2的指数次幂，6为余项 R R R，这四个数进行组合就可以表示1到13。通过上面的例子可知13件同类物品可以用4件物品来替代，这4件物品体积和价值分别相当于原物品的1件、2件、4件和6件。
  我们对每种物品的数量都利用上式来划分，若有 Q Q Q件原物品，那么划分后就变成了 log ⁡ 2 Q \log_2Q log2​Q件物品。利用以上思想，原问题就转换成了 ∑ i = 0 N − 1 log ⁡ 2 q i \sum_{i=0}^{N-1}\log_2q_i ∑i=0N−1​log2​qi​（ q i q_i qi​为第 i i i种物品的件数）件物品的0/1背包问题。

测试代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <cstring>
using namespace std;
int main(){
    size_t m,n;
    cin >> m >> n;///输入背包的体积容量和物品种类数
    vector<size_t> w,c;
    for(size_t i=0;i<n;i++){
        size_t tw,tc,q;
        cin >> tw >> tc >> q;///输入物品的体积、价值和数量
        for(size_t j=1;q>j;j*=2){///将q件物品组合成log q件物品
            w.push_back(tw*j);
            c.push_back(tc*j);
            q -= j;
        }
        w.push_back(tw*q);
        c.push_back(tc*q);
    }///将物品组合后，多重背包问题被改造成0/1背包问题
    vector<size_t> f(m+1,0);///申请内存空间，将各体积容量的背包初始化价值为0
    for(size_t i=0;i<w.size();i++){///枚举出各件物品
        for(size_t j=m;j>=w[i];j--){///利用小体积容量的最优背包求大体积容量的最优背包
            f[j] = max(f[j-w[i]]+c[i],f[j]);///状态转移方程
        }
    }///第一重循环枚举出各件物品，第二重循环枚举出各体积容量的最优背包，转移方程找出最佳的物品和最优背包组合
    cout << f[m] << endl;
    return 0;
}
电器爆破专家
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
完全背包问题
01-08
完全背包问题就是指已知一个体积为m的背包，共有n种物品，其中每种物品有其特定的体积v[i], 和权重w[i]，每种物品有无限个，要求从中选取物品装进背包，使总权值最大。 首先是总体需要弄清楚的模板发： 状态计算...
kp背包问题
qq_38802910的博客
04-09 292
kp背包问题
Knapsack背包问题入门
Maushawkin的博客
07-13 275
Knapsack背包问题入门0/1背包问题[O(C)]0/1背包的回溯问题0/1背包问题概率变种：多重背包问题[O(C*Σ\SigmaΣn)]完全背包问题 0/1背包问题[O©] 已知： 背包容量 C， 物品种类 N，每种物品有且仅有1个 每种物品拥有负载 w 和价格 p 两个属性。 设（N+1）×2 维数组{ vector<pair<int,int>> w_p }， w_p[n].first ------------ 物品n的负载 w_p[n].second ------- 物品n
背包问题：蜣螂优化算法（Dung beetle optimizer，DBO）求解背包问题(Knapsack Problem，KP)提供Matlab代码
IT猿手
12-16 713
0-1背包问题是组合约束优化中经典的NP-hard问题，一直以来都是学者研究的重点，传统算法求解此问题时，会随着问题规模的增加而算法所需时间成指数增长，而智能算法很好地解决了这一缺点，因而被广泛应用到求解背包问题中，例如：蜣螂优化算法。
62、分组背包问题（MCKP）Greedy、Dyer-Zemel、对偶界、动态规划实现
chaoyuzhang的博客
06-24 3662
原文链接：https://link.springer.com/chapter/10.1007/978-3-540-24777-7_11 不同于传统的背包问题，MCKP需要保证每个分组里面至少选一个物品，建模如下 其提出线性支配（LP-dominated）的定义如下 这是个筛选的过程，把处于支配（同一组内存在比你重量小但价值高的物品）的去掉，线性支配的定义会更强，比如3和7，其被线性支配，故被去掉，我个人理解这样在部分情况有可能把最优解去掉了，所以一般采用前者。 纯贪心算法如下 ..
动态规划专题——背包问题
热门推荐
⚡
02-13 3万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
背包问题Matlab求解
05-28
初始化背包容量、价值等必要因素，Matlab求解最优解。代码模块清晰，简单明了。
背包问题详解
04-09
这里有9种背包问题的详解，包括01背包问题，完全背包问题，多重背包问题，混合三种背包问题，二维费用的背包问题，分组的背包问题，有依赖的背包问题，泛华物品，背包问题问法的变化。每种背包问题不仅有详细的讲解...
01背包问题_01背包问题_
10-04
课程作业，实现算法实践书后的例题，实现01背包问题
3-增量背包问题四类实例
09-03
3-增量背包问题四类实例
蓝桥杯算法心得——矿石样本分析（贪心+两数之和）
晴天学长
05-19 434
链表的时间复杂度要知道查找（o（1））（o（n））一般都用ArrayList，除非是修改。
【算法】二分算法——x的平方根
2302_79031646的博客
05-17 857
用二分边界算法来求解——x的平方根，从暴力求解到二分的优化细说
力扣62 不同路径 Java版本
m0_47066863的博客
05-20 251
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。从左上角开始，总共有 3 条路径可以到达右下角。题目数据保证答案小于等于 2 * 109。输入：m = 3, n = 7。输入：m = 3, n = 2。输入：m = 7, n = 3。输入：m = 3, n = 3。问总共有多少条不同的路径？
【算法】【二叉树，DFS，哈希集合，分类讨论】力扣1110. 删点成林
未来就在脚下。
05-20 725
本题通过DFS遍历二叉树，结合分类讨论的方法，逐步删除指定节点并生成新的森林。该算法有效地处理了节点删除后树结构的调整问题，并通过哈希集合优化删除判断的时间复杂度，最终实现了高效的解决方案。
每周一算法：Prim算法求最小生成树
最新发布
少儿编程乔老师
05-23 686
在一个无向图中求边权和最小的生成树，即无向连通图的最小生成树（Minimum Spanning Tree，MST）。本文介绍使用Prim算法求最小生成树。
【会议征稿，中国算力大会分会，SPIE独立出版】2024算法、高性能计算与人工智能国际学术会议（AHPCAI 2024）
Jurio的博客
05-21 728
SPIE独立出版！AHPCAI前三届已完成EI检索！，AHPCAI 2023会后4个半月完成EI检索，【中国算力大会分会】2024算法、高性能计算与人工智能国际学术会议（AHPCAI 2024）,2024 International Conference on Algorithms, High Performance Computing and
22. 括号生成
编程SHARE的博客
05-20 251
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
LeetCode300：最长递增子序列
m0_50127633的博客
05-23 79
子序列 是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的。给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。
算法模块方法总结（数组）
Cobrander2_0的博客
05-17 163
二分查找（Binary Search）是一种在有序数组（必须是不能重复的，因为如果有重复的，会从几个符合的选项中输出一个，可能不合题意）中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。二分查找的思想是便于理解的，但是边界条件是很容易写错的。比如下面的。
python背包问题
08-26
背包问题是一个经典的优化问题，在计算机科学和运筹学中经常被讨论和研究。在Python中，可以使用动态规划来解决背包问题。 背包问题可以分为0-1背包问题和无限背包问题两种类型。 0-1背包问题要求在有限的物品集合...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值