DP之背包问题（01背包+完全背包+分组背包+多重背包+二维费用背包）

最新推荐文章于 2024-04-09 12:16:57 发布
最新推荐文章于 2024-04-09 12:16:57 发布
阅读量749 收藏
点赞数
分类专栏： 基础线性dp（背包，序列问题) 模板
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41444888/article/details/79426909
版权

首先是01背包，所有背包问题的基础，看这个博客很棒： 01背包，里面讲的很详细

常规二维写法 
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
int dp[1005][1005];
int main()
{
    int v[1005];
    int w[1005];

    int t;
    scanf("%d",&t);
    while(t --)
    {
        int n, m;
        scanf("%d%d",&n,&m);
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= n; i ++)
            scanf("%d",&v[i]);
        for(int j = 1; j <= n; j ++)
            scanf("%d",&w[j]);
        for(int i = 1; i <= n; i ++)
            for(int j = 0; j <= m; j ++)
        {
            if(j < w[i])
                dp[i][j] = dp[i-1][j];
            else
                dp[i][j] = max(dp[i-1][j],dp[i-1][j-w[i]] + v[i]);

        }
        printf("%d\n",dp[n][m]);
    }
    return 0;
}
dp[i][v]是由dp[i-1][v]和dp[i-1][v-c[i]]两个子问题递推而来，能否保证在推dp[i][v]时（也即在第i次主循环中推dp[v]时）能够得到dp[i-1][v]和dp[i-1][v-c[i]]的值呢？事实上，这要求在每次主循环中我们以v=V..0的顺序推dp[v]，这样才能保证推dp[v]时dp[v-c[i]]保存的是状态dp[i-1][v-c[i]]的值
优化空间后 
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
int main()
{
    int v[1005];
    int w[1005];
    int dp[1005];
    int t;
    scanf("%d",&t);
    while(t --)
    {
        memset(dp, 0, sizeof(dp));
        int n, V;
        scanf("%d%d",&n,&V);
        for(int i = 1; i <= n; i ++)
            scanf("%d",&w[i]);
        for(int i = 1; i <= n; i ++)
            scanf("%d",&v[i]);
        for(int i = 1; i <= n; i ++)
            for(int j = V; j >= v[i]; j --)
            {
                dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
            }
            printf("%d\n",dp[V]);
    }
    return 0;
}

然后是完全背包，之前01背包要求逆序，是为了防止物品重复放入，并且可以继承之前的状态，所以完全背包正序即可重复放入

和01背包相似，同一种物品有无数个

完全背包提升题HDU - 3092 
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
int main()
{
    int w[3] = {150, 200, 350};
    int v[3] = {150, 200, 350};
    int n, t;
    int f[10005];
    scanf("%d",&t);
    while(t --)
    {
        memset(f, 0, sizeof(f));
        scanf("%d",&n);
        for(int i = 0; i < 3; i ++)
            for(int j = 150; j <= n; j ++)
            if(w[i] <= j)
            f[j] = max(f[j], f[j - w[i]] + v[i]);
        printf("%d\n",n - f[n]);
    }
    return 0;
}
这道题自作聪明把for循环第二层写成了 
for(int j = 150; j <= n; j += 50)

其实n不一定是一个可以被50整除的数，联系完全背包建表过程就可以知道是错误的了，然而这样也不是不可以，只要保证n是可以整除50的数就ok，所以有了下面这个优化，应该又快了不少才对

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
int main()
{
    int w[3] = {150, 200, 350};
    int v[3] = {150, 200, 350};
    int n, t;
    int f[10005];
    scanf("%d",&t);
    while(t --)
    {
        memset(f, 0, sizeof(f));
        scanf("%d",&n);
        for(int i = 0; i < 3; i ++)
            for(int j = 150; j <= n; j += 50)
            if(w[i] <= j)
            f[j] = max(f[j], f[j - w[i]] + v[i]);
        int m = n - (n % 50);
        printf("%d\n",n - f[m]);
    }
    return 0;
}

然后是分组背包，分组背包将物品分为了几组，有了新的限制

分组背包使用一维数组的伪代码如下：
for 所有的组k
    for v=V..0
        for 所有的i属于组k
            f[v]=max{f[v],f[v-c[i]]+w[i]}

分组背包裸题HDU - 1712

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
int main()
{
    int n, m;
    int a[105][105];
    int dp[105];
    while(scanf("%d%d",&n,&m) != EOF&&n&&m)
    {
        memset(dp, 0, sizeof(dp));
        for(int i = 1; i <= n; i ++)
            for(int j = 1; j <= m; j ++)
            scanf("%d",&a[i][j]);
        for(int i = 1; i <= n; i ++)
            for(int j = m; j > 0; j --)//倒叙保证每天只能选一种，形似01背包
                for(int k = 1; k <= j; k ++)
                dp[j] = max(dp[j], dp[j - k] + a[i][k]);
        printf("%d\n",dp[m]);
    }
    return 0;
}

为什么倒叙就是01背包而正序就是完全背包呢，因为倒叙无法继承之前的状态，只能选择一个物品，而正序可以在背包容量之内无限添加该物品，关于这点画个图模拟一下就明白了，对于多重背包，就是之前01背包的扩展版本，每个物品的数量都是有限个，要不然不选择该物品，要不然就选择k个，这种问题显然不能用完全背包的思想做，因为完全背包问题中，每一个物品有无限个，而多重背包是有限个，此时我们应该向01背包问题靠拢

for(int i = 1; i <= n; i ++)
            for(int j = V; j >= v[i]; j --)

这是01背包核心代码，此时倒叙保证每次只能选择一个物品，如果想要选择多个呢，此时需要在两个for之间加上一个循环，该循环的目的是保证选择该物品的同时，可以延续之前的状态，以达到选择多个物品的目的，必须我要选择两个a物品，用01背包的代码只能完成选择一个，如果再跑一边第二层循环，就能延续之前选择一个a物品的状态，从而实现a物品的第二次添加，所以再跑一边第二层循环，又可以添加一次，即有几个a物品，就跑几次第二层循环，以达到同种物品的多次添加，这样就和01背包很相似了，个人理解描述有限。。

for(int i = 1; i <= m; i ++)
            for(int j = 1; j <= num[i]; j ++)
                for(int k = n; k >= v[i]; k --)

01背包两层循环之间添加了一个for循环，这就是上面所说的01背包状态延续版本--多重背包

多重背包裸题 HDU - 2191 
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
int w[105], v[105], num[105], dp[105];
int main()
{
    int m, n;
    int t;
    scanf("%d",&t);
    while(t --)
    {
        memset(dp, 0, sizeof(dp));
        scanf("%d%d",&n,&m);
        for(int i = 1; i <= m; i ++)
            scanf("%d%d%d",&v[i],&w[i],&num[i]);
        for(int i = 1; i <= m; i ++)
            for(int j = 1; j <= num[i]; j ++)
                for(int k = n; k >= v[i]; k --)
                dp[k] = max(dp[k], dp[k - v[i]] + w[i]);
            printf("%d\n",dp[n]);
    }
    return 0;
}

还是这道题，看到大佬写的方法，发现还挺好理解，就是二进制解决问题方面不会证明。。。但确实是快了不少

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
int dp[1005];
int c[1005], w[1005], num[1005];
int m, n;
void zero_pack(int cost, int weigh, int n)//01背包
{
    for(int i = n; i >= cost; i --)
        dp[i] = max(dp[i], dp[i - cost] + weigh);
}
void complete_pack(int cost, int weigh, int n)//完全背包
{
    for(int i = cost; i <= n; i ++)
        dp[i] = max(dp[i], dp[i - cost] + weigh);
}
int multi_pack(int c[], int w[], int num[], int n, int m)//多重背包
{
    memset(dp, 0, sizeof(dp));
    for(int i = 1; i <= n; i ++)
    {
        if(num[i] * c[i] > m)//此种情况视为该物品无限个，用完全背包解决
            complete_pack(c[i], w[i], m);
        else//否则用01背包解决，用二进制解决问题降低时间复杂度，必定可以凑出结果
        {
            int k = 1;
            while(k < num[i])
            {
                zero_pack(k*c[i], k*w[i], m);
                num[i] -= k;
                k <<= 1;
            }
            zero_pack(num[i]*c[i], num[i]*w[i], m);
        }
    }
    return dp[m];
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t --)
    {
        scanf("%d%d",&m,&n);
        for(int i = 1; i <= n; i ++)
            scanf("%d%d%d",&c[i],&w[i],&num[i]);
        printf("%d\n",multi_pack(c, w, num, n, m));
    }
    return 0;
}

关于二进制的问题，在网上找了个证明

定理：一个正整数n可以被分解成1,2,4,…,2^(k-1),n-2^k+1（k是满足n-2^k+1>0的最大整数）的形式，且1～n之内的所有整数均可以唯一表示成1,2,4,…,2^(k-1),n-2^k+1中某几个数的和的形式。

证明如下：

（1） 数列1,2,4,…,2^(k-1),n-2^k+1中所有元素的和为n，所以若干元素的和的范围为：[1, n]；

（2）如果正整数t<= 2^k – 1,则t一定能用1,2,4,…,2^(k-1)中某几个数的和表示，这个很容易证明：我们把t的二进制表示写出来，很明显，t可以表示成n=a0*2^0+a1*2^1+…+ak*2^（k-1），其中ak=0或者1，表示t的第ak位二进制数为0或者1.

（3）如果t>=2^k,设s=n-2^k+1，则t-s<=2^k-1，因而t-s可以表示成1,2,4,…,2^(k-1)中某几个数的和的形式，进而t可以表示成1,2,4,…,2^(k-1)，s中某几个数的和（加数中一定含有s）的形式

然后就是二维费用背包，即选择一种物品，需要付出两种费用，在之前的维度上再加一维就行，和之前一样的，倘若是01背包，就倒叙，完全背包就正序，第一层循环不变，仍旧遍历物品种类，第二三层循环可以彼此替换，第二三层决定是01还是完全背包
二维背包 看这个博客很棒

二维背包裸题HDU - 2159 

直接挂代码 
#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<set>
#include<map>
#include<queue>
#include<cmath>
using namespace std;
#define inf 0x3f3f3f3f
int main()
{
    int v[105], w[105];
    int dp[105][105];
    int m, n, k, s;
    while(scanf("%d%d%d%d",&n,&m,&k,&s) != EOF)
    {
        memset(dp, 0, sizeof(dp));
        int ans = inf;
        int flag = 0;
        for(int i = 1; i <= k; i ++)
            scanf("%d%d",&v[i],&w[i]);
        for(int i = 1; i <= k; i ++)
            for(int j = w[i]; j <= m; j ++)
                for(int k = 1; k <= s; k ++)
                {
                    dp[j][k] = max(dp[j][k], dp[j - w[i]][k - 1] + v[i]);
                    if(dp[j][k] >= n && j < ans)
                    {
                        flag = 1;
                        ans = j;
                    }
                }
            if(flag) printf("%d\n",m - ans);
            else printf("-1\n");
    }
    return 0;
}
GocNeverGiveUp
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
背包DP问题（0/1背包，完全背包，多重背包，分组背包）
JomQ的博客
08-23 1168
背包DP问题0/1背包问题模型状态转移方程完全背包二级目录三级目录多重背包二级目录三级目录分组背包二级目录三级目录 0/1背包 问题模型 给定N个物品，其中第i个物品的体积为Vi，价值为Wi。有一个容积为M的背包。要求放入物品的总体积不超过M的情况下，总价值最高。 状态转移方程 完全背包 二级目录 三级目录 多重背包 二级目录 三级目录 分组背包 二级目录 三级目录 ...
DP背包问题模板：01背包 与 完全背包
Plus Ultra！
02-19 528
01背包问题： 有n件物品，每件物品的重量为w[i]，价值为c[i]。现有一个容量为V的背包，问如何选取物品放入背包，使得背包内物品的总价值最大。其中每种物品只有1件。 dp[i][j]：前 i 件物品装入容量为 j 的背包中得到的最大价值 对第 i 件物品，有2种前状态： a. 选择第 i 件物品，则 dp[i][j] = dp[i-1][ j-w[i] ] + c[i] b. 不选择第 ...
背包问题详解（01背包，完全背包，多重背包，混合背包，二维费用背包……）
10-16
背包问题详解 01背包，完全背包，多重背包，混合背包，二维费用背包，分级背包，泛化物品等等的分析思路，解题技巧，还有各种背包问题的题目解答。
背包DP问题（01背包+完全背包+分组背包+多重背包+混合背包+二维费用的背包）
柠檬的博客~~~
08-17 1337
背包DP问题 01背包问题 一、01背包问题 问题： 有N件物品和一个容量为V的背包。第i件物品的费用（即体积，下同）是w[i]，价值是c[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 基本思路： 　　这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。 　　用子问题定义状态：即f[i][v]表示前i件物品(部分或全部)恰放入一个容量为v的背包...
DP - 背包问题 (01背包(方案求解) + 完全背包 + 多重背包 + 分组背包 + 二维费用背包 + 混合背包)
njuptACMcxk的博客
04-11 543
DP - 背包问题 文章目录DP - 背包问题1、01背包问题 1、01背包问题 题目： 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 ...
背包问题：01背包，完全背包，多重背包，混合背包，二维费用背包，分组背包问题
weixin_43758492的博客
07-26 369
1、01背包问题 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。输出选了哪些物品。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 题解 一、dp矩阵，横轴代表背包的容量，从0开始到V。纵轴代表物品数量，0代表前0个物品，1代表前1个物
完全背包问题+01背包问题+分组背包+多重背包 总结
一瓢西湖水的博客
02-02 472
本文转载自：https://blog.csdn.net/weixin_43849505/article/details/89423390 ...
什么是01背包问题动态规划以及学习01背包问题动态规划的意义
最新发布
05-09
在01背包问题中，我们通常使用一个二维数组dp[i][j]来表示当前的状态，其中i表示已考虑前i件物品，j表示背包当前剩余的承重为j时所能获得的最大价值。 **2. 动态规划的递推关系** 对于每一件物品i，有两种选择： -...
Python背包问题动态规划求解（一维和二维数组）.zip
01-21
1. **二维背包问题**：与一维不同，二维背包问题考虑了物品的数量限制。每个物品可能有多件，每件的重量和价值相同。 2. **动态规划状态定义**：这里需要用到一个二维数组dp[i][j]，表示前i个物品，容量为j时的最大...
01背包问题_01背包问题_
10-04
在01背包问题中，我们可以定义一个二维数组dp，其中dp[i][j]表示前i件物品中选取若干件总重量不超过j时的最大价值。状态转移方程可以表示为： 1. 如果当前物品的重量超过了背包剩余容量j，那么第i件物品无法被选中...
动态规划专题——背包问题
热门推荐
⚡
02-13 4万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
分组背包问题
Jefferson__的博客
07-15 291
题目描述： 有N组物品和一个容量是V的背包。 每组物品有若干个，同一组内的物品最多只能选一个。 每件物品的体积是vij，价值是wij，其中i是组号，j是组内编号。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式： 第一行有两个整数N，V，用空格隔开，分别表示物品组数和背包容量。 接下来有N组数据： 每组数据第一行有一个整数Si，表示第i个物品组的物品数量； 每组数据接下来有Si行，每行有两个整数vij,...
背包九讲-背包问题代码奉上
BOWWOB的博客
08-15 400
01背包题目链接 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤1000 0<vi,wi≤1000 输入样例 4
背包问题详解（01背包，完全背包，多重背包，分组背包）
走在努力路上的自己的博客
04-09 8663
有 N 件物品和一个容量是 V的背包。每件物品只能使用一次。第 i 件物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。输入格式第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。输出格式输出一个整数，表示最大价值。数据范围0
多重背包问题与分组背包
qq_62272360的博客
05-26 381
多重背包的含义： 物品数量不再是无穷多。 思路，既然物品个数有限，但还要判断要装几个，我们可以用暴力的做法，三重循环，每层循环控制自己的变量，容易理解。第三层循环就是控制装的物品的个数，我们通过分析可以得知，在使用次数不超过物品提供个数的同时，还要小于背包的空间限制。 #include<bits/stdc++.h> using namespace std; const int N = 1010; int v[N]; int w[N]; int s[N]; int f[N][N
01背包、完全背包、多重背包、分组背包问题，一文读懂
Kepler11的博客
04-12 3020
背包问题是一种组合优化的 NP 完全问题：有 N 个物品和容量为 W 的背包，每个物品都有 自己的体积 w 和价值 v，求拿哪些物品可以使得背包所装下物品的总价值最大。 0-1背包 有N件物品和一个最多能背重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。 每件物品都有选与不选两种情况，那么这个问题完全可以用回溯法来暴力搜索，时间复杂度为O(n2)O(n^2)O(n2)，因为暴力解法时间复杂度太高，所以才要用
多重背包与分组背包的区别
江上酒
02-06 498
多重背包 分组背包 多重背包是每件物品最多选择s个,可以选1,2,3,... 分组背包是每组有多个,但是这一组最多选择一个 对于多重背包,枚举物品,然后体积(一维倒序)之后决策,选择k个 #include<iostream> #include<algorithm> using namespace std; const int N=110; int f[N]; int main() { int n,m; cin>>n>>m;
01背包、完全背包、多重背包、分组背包总结
长期更新自学笔记
11-23 886
我们现在需要根据(3)式的结果，推出(1)式的结果，(1)式的后s[i]项和(3)式的前s[i]项完全一样，但我们无法使用(3)式中s[i]+1项的最大值，推出(3)式的前s[i]项的最大值，所以无法使用完全背包问题的优化方式。一维形式中，如果逆序遍历容量，计算后面容量时，使用的就是没有计算过的结果，体现在二维中，使用的就是上一层的结果，这是不对的。，如果我们用k+1个新的物品，来代替多重背包的一个物品，使用01背包的方式计算出这k+1个物品选或不选。，如果说原来有n类物品，每类物品有s个，总共。
01背包问题深度解析与解法汇总
包含了多个博客和文章链接，涵盖了01背包问题的不同解法，包括动态规划的运用，以及对背包问题的深入讲解，如四种解题方法、一次搞定三种背包问题的策略，还有针对多重背包问题的原理和代码实现。" 01背包问题是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值