背包问题总结

无限酸奶

已于 2023-04-15 15:37:21 修改

阅读量559

点赞数 1

分类专栏：数据结构与算法文章标签：算法

于 2023-04-02 23:06:29 首次发布

本文链接：https://blog.csdn.net/ntr851217/article/details/129845751

版权

数据结构与算法专栏收录该内容

11 篇文章 1 订阅

订阅专栏

01背包问题

每件物品只能用0次或者1次

什么是背包问题？

背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。

题目：

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 $V_i$ ，价值是 $W_i$ 。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式：

第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

输出格式：

输出一个整数，表示最大价值。

数据范围：

0<N,V≤1000
0< $V_i$ , $W_i$ ≤ 1000

输入样例：

输出样例：

原题链接：2. 01背包问题 - AcWing题库

朴素做法：

用一个二维数组f[i][j]来存储，在不超过体积j的前提下，从前i个物品中选,能够得到的最大价值。

当我们选择第i件物品时，仅有两种选法，选或者不选第i件物品。

选第i件物品，相当于已经选择了第i件物品，再从中选择不超过j-v[i]的物品，对应的价值就是f[i-1][j-v[i]]+w[i]相当于，所以有前i-1件物品的价值可以推出第i件物品的价值。
当不选第i件物品时，说明从前i-1件物品中选择更有价值,即f[i-1][j];

通过以上可以得出二维的递推公式f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);

由递推公式可以推出第i层物品是由第i-1层物品决定的。

参考代码：

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=1010;
int f[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=0;j<=m;j++)
        {
            f[i][j]=f[i-1][j];
            if(j>=v[i])
            {
                f[i][j]=max(f[i][j],f[i-1][j-v[i]]+w[i]);
            }
        }
    }
    int res=0;
    for(int i=0;i<=m;i++)res=max(res,f[n][i]);
    cout<<res<<endl;
    return 0;
}

我们还能进行优化吗？当然可以，可以用动态数组进行优化，但是没有必要。我们可以将二维优化为一维。但是我们如何进行优化呢？

假如我们将[i]这一层去掉，那么f[j]到底表示什么含义呢？f[j]其实表示的就是第i层的不超过体积j的最大价值，而我们实际上要的是从第i-1层的f[j]递推到下一层。为什么会出现这种情况呢？这是因为我们用二维数组时j是从小到大进行枚举状态(0~m).那么怎么解决呢？

其实我们可以从大到小枚举所有的j。对于一个二维f[i][j]如果从小到大进行枚举，得到一个第i层的f[i][j]，可以是从第i-1层的f[i-1][j]或者f[i-1][j-v[i]],第i层的f[i][j+v[i]]是由i-1的f[i-1][j]或者f[i-1][j+v[i]],如果减到一维那么第i层的f[i][j+v[i]]是由上一层的f[i-1][j]更新过来的，而f[i-1][j]已经更新成了第i层的f[i][j],这样以来肯定会出错，如果从大到小枚举，前面一层的状态肯定没有用过，所以不会出现这样的问题。

可以得到一维的状态转移公式f[j]=max(f[j],f[j-v[i]]+w[i])

使用滚动数组进行优化：

参考代码：

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=1010;
int f[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=m;j>=v[i];j--)
        {
            f[j]=max(f[j],f[j-v[i]]+w[i]);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

完全背包问题

完全背包问题和01背包问题不同的是每种物品有无限件。

题目：

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。

第 i 种物品的体积是 $V_i$ ，价值是 $W_i$ 。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式：

第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行两个整数 $V_i$ , $W_i$ ，用空格隔开，分别表示第 i 种物品的体积和价值。

输出格式：

输出一个整数，表示最大价值。

数据范围：

0<N,V≤1000
0< $V_i,W_i$ ≤1000

输入样例：

输出样例：

原题链接：3. 完全背包问题 - AcWing题库

分析：

我们要求的是怎样使不超过背包体积的情况下，且总价值最大的值。可以将f[i][j]的状态表示为，选0件第i件物品总体积不超过j的所有集合，选1件第i件物品不超过体积j的所有集合····直到体积不超过j为止。所以我们可以将其转换成多种情况，只要找出每种情况再求出它们的最大值即可。

当我们选择0件第i件物品时，相当于从前i个物品中选总体积不超过j的方案的集合，因为我们没有选择第i件物品所以f[i][j]相当于f[i-1][j]。
当我们选择k件第i件物品时，相当于k件i物品的状态已经确定，只需要让前i-1件选总体积不超过j-kv[i]的方案的集合最大即可。

所以我们只需要求所有情况的最大值即可。

f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i],f[i-1][j-2v[i]]+2w[i],···,f[i-1][j-kv[i]]+kw[i],····)

参考代码：

#include<iostream>
 
using namespace std;
 
const int N = 1010;
 
int f[N][N];
int v[N],w[N];
 
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++) {
            for(int k = 0 ; k*v[i]<=j ; k++)
                f[i][j] = max(f[i][j],f[i-1][j-k*v[i]]+k*w[i]);
        }
    }
 
    cout<<f[n][m]<<endl;
}

由于我们最终的表达式不仅含有i和j还有k，所以我们需要一个三重循环来求最大值，那么循环完就是10^9所以一定会超时。所以怎么进行优化呢？

f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i],f[i-1][j-2v[i]]+2w[i],···,f[i-1][j-kv[i]]+kw[i],····) (1)

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

我们让(1)式中j=j-v[i]，我们可以得到(2)式，我们可以(1)式发现红色部分只是比(2)式红色部分每一项多了一个w[i],我们让(2)式左右两边加上w[i],这样我们就可以得到状态转移方程。

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

通过对比01背包状态转移方程和完全背包的状态转移方程，只有i不同，所以我们仿照一维01背包进行优化时，只需要将j从大到小改成从小到大。

f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i]);    //01背包
f[i][j]=max(f[i-1][j],f[i][j-v[i]]+w[i]);  //完全背包

朴素做法：

#include<iostream>
using namespace std;
const int N=1010;
int f[N][N];
int v[N],w[N];
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]<<endl;
    return 0;
}

使用滚动数组进行优化：

仿照01背包将j从小到大枚举

#include<iostream>
using namespace std;
const int N=1010;
int f[N];
int v[N],w[N];
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]<<endl;
    return 0;
}

多重背包问题

多重背包问题其实就是01背包问题的扩展。

题目：

有 N 种物品和一个容量是 V 的背包。

第 i 种物品最多有 $S_i$ 件，每件体积是 $V_i$ ，价值是 $W_i$ 。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式：

第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。

接下来有 N 行，每行三个整数 $V_i$ , $W_i$ , $S_i$ ，用空格隔开，分别表示第 i 种物品的体积、价值和数量。

输出格式：

输出一个整数，表示最大价值。

数据范围：

0<N,V≤100
0< $V_i$ , $W_i$ , $S_i$ ≤100

输入样例：

输出样例：

原题链接：4. 多重背包问题 I - AcWing题库

我们可以发现多重背包和01背包、完全背包不同的是第i件物品的限制，所以我们只需要在01背包的基础上再加一层循环来枚举第i层选择的所有情况

参考代码：

#include<iostream>
using namespace std;
const int N=110;
int f[N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        int v,w,s;
        cin>>v>>w>>s;
        for(int j=m;j>=0;j--)
        {
            for(int k=1;k<=s&&k*v<=j;k++)
            {
                f[j]=max(f[j],f[j-k*v]+k*w);
            }
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

在这道题中因为我们的数据比较小，所以我们用O(n^3)的时间复杂度就可以通过，但是如果我们的数据改为：

数据范围：

0<N≤1000
0<V≤2000
0< $V_i$ , $W_i$ , $S_i$ ≤2000

如果还用O(n^3)的方法，10^9肯定会超时，所以我们怎么去优化呢？

原题链接：5. 多重背包问题 II - AcWing题库

多重背包的二进制优化方法

首先我们想的是如何将一个多重背包问题转换成一个0/1背包问题。假设我们第i种物品有s个，体积是v价值是w，我们可以将s个物品分成s份，每份最多有一个，那么我们就将一个问题转换成了0/1背包问题，如果我们直接拆，那么我们有2000个i种物品就拆成2000份，我们有1000种物品，那么就是2*10^6种情况，最后也是10^9，也会超时。如果我们能找到到一种拆法，让拆的物品份数足够少，那么我们就完成了优化。

比如我们的s=7，那么我们暴力的拆法是将7拆成7个1，如果我们想要让拆开的数的组数最小，我们可以用二进制的方法来表示，7=1+2+4，但这样同时也存在一个问题如何表示一个不是2的幂的一个数字，比如10，因为三个二进制数字最多只能表示到7，四个二进制数字又表示15又超过了10。我们可以这样计算所需二进制数的数量，每次减去一个2的幂，直到减到这个数是一个负数，那么此时表示的二进制数字一定能表示s份。这样我们就把s优化成了 $log_2S$ ，时间复杂度就变成了1000* $log_22000$ *2000约等于2*10^7，这样就完成了优化。

参考代码：

#include<iostream>
#include<algorithm>
using namespace std;
const int N=2010;
int f[N];
int v,w,s;
int n,m;
struct Good
{
    int v,w;    
};
vector<Good> goods;
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>v>>w>>s;
        for(int k=1;k<=s;k*=2)
        {
            s-=k;
            goods.push_back({k*v,k*w});
        }
        if(s>0)goods.push_back({s*v,s*w});
    }
    for(auto good:goods)
    {
        for(int j=m;j>=good.v;j--)
        {
            f[j]=max(f[j],f[j-good.v]+good.w);
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

分组背包问题

分组背包问题其实就是0/1背包问题的一个变种。0/1背包是第i种物品选择0/1个，分组背包问题是每组选择0/1个，不同点是每组物品有s个，我们要枚举0～s种情况。

题目：

有 N 组物品和一个容量是 V 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 $V_i_j$ ，价值是 $W_i_j$ ，其中 i 是组号，j 是组内编号。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式：

第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。

接下来有 N 组数据：

每组数据第一行有一个整数 $S_i$ ，表示第 i 个物品组的物品数量；
每组数据接下来有 $S_i$ 行，每行有两个整数 $V_i_j$ , $W_i_j$ ，用空格隔开，分别表示第 i 个物品组的第 j 个物品的体积和价值；

输出格式：

输出一个整数，表示最大价值。

数据范围：

0<N,V≤100
0< $S_i$ ≤100
0< $V_i_j$ , $W_i_j$ ≤100

输入样例：

输出样例：

原题链接： 9. 分组背包问题 - AcWing题库

参考代码：

#include<iostream>
#include<algorithm>
using namespace std;
const int N=110;
int f[N],v[N],w[N];
int n,m;
int main()
{
    cin>>n>>m;
    for(int i=0;i<n;i++)
    {
        int s;
        cin>>s;
        for(int j=0;j<s;j++)cin>>v[j]>>w[j];
        for(int j=m;j>=0;j--)
        {
            for(int k=0;k<s;k++)
            {
                if(j>=v[k])f[j]=max(f[j],f[j-v[k]]+w[k]);
                //保证背包剩余的体积一定是大于0
            }
        }
    }
    cout<<f[m]<<endl;
    return 0;
}

最后再解释一下为什么是i，j，k这个顺序进行枚举，不能是i，k，j这个顺序进行枚举吗？

不能。

这里引用y总的解释，背包问题在优化完空间之后，循环顺序必须是物品、体积、决策。这里的第三维虽然看似是在循环物品，但其实是循环当前物品组中的决策：我是选第1个物品呢，还是选第2个物品呢，还是选第3个物品呢，以此类推。

总结

处理背包问题的一个思路：

处理背包问题的思路主要包括状态定义、状态转移和边界处理。

1. 确定问题类型。背包问题分为01背包、完全背包和多重背包三种类型，需要根据具体问题的要求来选择对应的问题类型。

2. 确定状态。将问题抽象成"在选取若干种物品时，限制总重量/总体积的条件下，能获取到的最大价值"，因此，背包问题的状态包括选择的物品编号和背包剩余容量（或已使用容量）。

3. 定义状态转移方程。状态转移方程即当前状态的最优值与之前的状态有何关联。具体来说，需要根据问题类型分别写出01背包、完全背包和多重背包的状态转移方程。

4. 确定边界条件。状态转移方程需要依赖于边界条件，对于背包问题而言，边界条件通常是背包容量为0时的最优值为0。

5. 计算答案。根据状态转移方程计算出最优值，即选取物品的最大价值。

以此类推，以上五步是处理所有背包问题的通用思路。

无限酸奶

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
背包问题总结

我们要求的是怎样使不超过背包体积的情况下，且总价值最大的值。可以将f[i][j]的状态表示为，选0件第i件物品总体积不超过j的所有集合，选1件第i件物品不超过体积j的所有集合····直到体积不超过j为止。f[j]其实表示的就是第i层的不超过体积j的最大价值，而我们实际上要的是从第i-1层的f[j]递推到下一层。我们让(1)式中j=j-v[i]，我们可以得到(2)式，我们可以(1)式发现红色部分只是比(2)式红色部分每一项多了一个w[i],我们让(2)式左右两边加上w[i],这样我们就可以得到状态转移方程。
复制链接

扫一扫