刷透背包（01 背包，完全背包，多重背包，分组背包，混合背包，二维费用背包）

最新推荐文章于 2024-04-09 12:16:57 发布
最新推荐文章于 2024-04-09 12:16:57 发布
阅读量806 收藏 9
点赞数 1
分类专栏： 算法 文章标签： 动态规划 背包问题 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013570834/article/details/116350364
版权

01 背包和完全背包是重点，分组背包、二维费用是 01 背包的扩展，多重背包是受限制的完全背包

01 背包

解题思路

QQ20210502-080900.png

代码

原始做法

#include <iostream>

using namespace std;

const int N = 1010;
int v[N], w[N], f[N][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 = 1; j <= m; j++) {
            f[i][j] = f[i - 1][j];
            if (j >= v[i]) f[i][j] = max(f[i - 1][j - v[i]] + w[i], f[i][j]);
        }
    }
    cout << f[n][m] << endl;
    
    return 0;
}

优化空间

#include <iostream>

using namespace std;

const int N = 1010;
int v[N], w[N], f[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 = m; j >= v[i]; j--) f[j] = max(f[j - v[i]] + w[i], f[j]);
    }
    cout << f[m] << endl;
    
    return 0;
}

完全背包

解题思路

QQ20210502-084712.png

代码

原始做法 O(N^3)

#include <iostream>

using namespace std;

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

优化时间 O(N^2)

#include <iostream>

using namespace std;

const int N = 1010;
int v[N], w[N], f[N][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 = 1; j <= m; j++) {
            f[i][j] = f[i - 1][j];
            if (j >= v[i]) f[i][j] = max(f[i - 1][j], f[i][j - v[i]] + w[i]);
        }
    }
    cout << f[n][m] << endl;
    
    return 0;
}

优化空间

#include <iostream>

using namespace std;

const int N = 1010;
int v[N], w[N], f[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 - v[i]] + w[i], f[j]);
        }
    }
    cout << f[m] << endl;
    
    return 0;
}

多重背包

解题思路

朴素的多重背包，在朴素的完全背包的基础，加一个次数限制，即可

朴素做法：一个一个拆 O ( N ) O(N) O(N)

二进制优化：类似于快速幂的拆法 O ( l o g N ) O(logN) O(logN)，拆成多组

比如说：a 物品有 13 个

朴素做法就是一个一个的试，最终试到 13 个

二进制优化，则是拆成 5 组，{1, 2, 4, 8, 1} 尝试。因为由 {1, 2, 4, 8, 1} 这个集合里面的子集能凑 0 ~ 13 的任意一个数

代码

原始做法 O(N^3)

#include <iostream>

using namespace std;

const int N = 110;
int v[N], w[N], s[N], f[N][N];

int main() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> v[i] >> w[i] >> s[i];

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            for (int k = 0; j >= k * v[i] && k <= s[i]; k++) {
                f[i][j] = max(f[i][j], f[i - 1][j - k * v[i]] + k * w[i]);
            }
        }
    }
    cout << f[n][m] << endl;
    
    return 0;
}

二进制优化 O(N^2logN)

#include <iostream>

using namespace std;

const int N = 10000;
int v[N], w[N], f[N][N];

int main() {
    int n, m;
    cin >> n >> m;
    int cnt = 1;
    for (int i = 1; i <= n; i++) {
        int a, b, s;
        cin >> a >> b >> s;
        for (int k = 1; k <= s; s -= k, k <<= 1) {
            v[cnt] = a * k, w[cnt] = b * k;
            cnt++;
        }
        if (s) {
            v[cnt] = a * s, w[cnt] = b * s;
            cnt++;
        }
    }
    
    n = cnt;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; 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]);
        }
    }
    cout << f[n][m] << endl;
    
    return 0;
}

在二进制优化上再优化空间

#include <iostream>

using namespace std;

const int N = 10000;
int v[N], w[N], f[N];

int main() {
    int n, m;
    cin >> n >> m;
    int cnt = 1;
    for (int i = 1; i <= n; i++) {
        int a, b, s;
        cin >> a >> b >> s;
        for (int k = 1; k <= s; s -= k, k <<= 1) {
            v[cnt] = a * k, w[cnt] = b * k;
            cnt++;
        }
        if (s) {
            v[cnt] = a * s, w[cnt] = b * s;
            cnt++;
        }
    }
    
    n = cnt;
    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 背包，状态转移与 01 一致。只是拓展了分组内物品的枚举

代码

原始做法

#include <iostream>

using namespace std;

const int N = 110;
int v[N][N], w[N][N], s[N], f[N][N];

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 = 1; 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] << endl;
    
    return 0;
}

优化空间

#include <iostream>

using namespace std;

const int N = 110;
int v[N][N], w[N][N], s[N], f[N];

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 = m; j >= 0; j--) {
            for (int k = 1; k <= s[i]; k++) {
                if (j >= v[i][k]) f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
            }
        }
    }
    cout << f[m] << endl;
    
    return 0;
}

混合背包

解题思路

01 背包与分组背包和完全背包混合，这三者的状态表示是相同的，根据判断背包的类型，分别做状态转移即可

代码

原始做法 O(N^3)

#include <iostream>

using namespace std;

const int N = 1010;
int f[N][N];

int main() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        int v, w, s;
        cin >> v >> w >> s;
        if (s == -1) { // 01 背包
            for (int j = 1; j <= m; j++) {
                f[i][j] = f[i - 1][j];
                if (j >= v) f[i][j] = max(f[i][j], f[i - 1][j - v] + w);
            }
        } else if (s == 0) { // 完全背包
            for (int j = 1; j <= m; j++) {
                f[i][j] = f[i - 1][j];
                if (j >= v) f[i][j] = max(f[i - 1][j], f[i][j - v] + w);
            }
        } else { // 多重背包
            for (int j = 1; j <= m; j++) {
                for (int k = 0; j >= k * v && k <= s; k++) {
                    f[i][j] = max(f[i][j], f[i - 1][j - k * v] + k * w);
                }
            }
        }
    }
    cout << f[n][m] << endl;
    
    return 0;
}

优化 O(N^2logN)

#include <iostream>

using namespace std;

const int N = 1010;
int f[N];

int main() {
    int n, m;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        int v, w, s;
        cin >> v >> w >> s;
        if (s == -1) { // 01 背包
            for (int j = m; j >= v; j--) {
                if (j >= v) f[j] = max(f[j], f[j - v] + w);
            }
        } else if (s == 0) { // 完全背包
            for (int j = v; j <= m; j++) {
                f[j] = max(f[j], f[j - v] + w);
            }
        } else { // 多重背包
            for (int k = 1; k <= s; s -= k, k <<= 1) {
                for (int j = m; j >= k * v; j--) f[j] = max(f[j], f[j - k * v] + k * w);
            }
            if (s) {
                for (int j = m; j >= s * v; j--) f[j] = max(f[j], f[j - s * v] + s * w);
            }
        }
    }
    cout << f[m] << endl;
    
    return 0;
}

二维费用背包

解题思路

QQ20210502-214029.png

代码

原始做法

#include <iostream>
using namespace std;

const int N = 1010, M = 110;
int v[N], m[N], w[N];
int f[N][M][M];

int main() {
    int n, a, b;
    cin >> n >> a >> b;
    for (int i = 1; i <= n; i++) cin >> v[i] >> m[i] >> w[i];
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= a; j++) {
            for (int k = 1; k <= b; k++) {
                f[i][j][k] = f[i - 1][j][k];
                if (j >= v[i] && k >= m[i])
                    f[i][j][k] = max(f[i][j][k], f[i - 1][j - v[i]][k - m[i]] + w[i]);
            }
        }
    }
    cout << f[n][a][b] << endl;

    return 0;
}

优化空间

#include <iostream>
using namespace std;

const int N = 1010, M = 110;
int v[N], m[N], w[N];
int f[M][M];

int main() {
    int n, a, b;
    cin >> n >> a >> b;
    for (int i = 1; i <= n; i++) cin >> v[i] >> m[i] >> w[i];
    
    for (int i = 1; i <= n; i++) {
        for (int j = a; j >= v[i]; j--) {
            for (int k = b; k >= m[i]; k--) {
                f[j][k] = max(f[j][k], f[j - v[i]][k - m[i]] + w[i]);
            }
        }
    }
    cout << f[a][b] << endl;

    return 0;
}

参考资料

不搞数学的汤老师
关注
  • 1
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
什么是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时的最大...
ch4(DP)——背包问题（01背包、完全背包、多重背包、分组背包、混合背包）
kingdom365的博客
09-01 308
1.自然语言描述 ① 01背包问题：有n个物品，每个物品有相应的体积vi和价值wi，对于一个物品，要么装入背包，要么不装入；有一个体积为V的背包，怎么装物品才能使背包中物品的价值最大？ ② 完全背包问题：有n种物品，每种物品有相应的体积vi和价值wi，对于一种物品可以选任意多个装入背包（即每种物品的数量是无穷大的）有一个体积为V的背包，怎么装物品才能使背包中物品的价值最大？ ③ 多重背包问题：有n种物品，每种物品有相应的体积vi和价值wi，第i种物品的数量是si个；有一个体积为V的背包，怎么装物品才能使背包
DP模型——背包模型 02 （完全、多重、二维费用、分组）
INGg__的博客
07-28 472
文章目录完全背包方案数买书货币系统货币系统（NOIP）题意题解多重背包庆功会二维费用背包板子潜水员状态表示属性状态计算Code2021山东省赛分组背包问题机器分配金明的预算方案 完全背包 方案数 买书 即求不超过n元钱的方案数 优化也是跟求最值的完全背包一样 f[i][j]=f[i−1][j]+f[i−1][j−1∗v[i]]+⋯f[i][j]=f[i-1][j]+f[i-1][j-1*v[i]]+\cdotsf[i][j]=f[i−1][j]+f[i−1][j−1∗v[i]]+⋯变形为f[i][j]=f[
背包九讲系列2——混合背包、二维费用背包、分组背包
yukunqi的博客
09-03 1120
4 混合三种背包问题4.1 问题如果将前面1、2、3中的三种背包问题混合起来。也就是说，有的物品只可以取一次（01 背包），有的物品可以取无限次（完全背包），有的物品可以取的次数有一个上限（多重背包）。应该怎么求解呢？4.2 01 背包与完全背包的混合 考虑到01 背包和完全背包中给出的伪代码只有一处不同，故如果只有两类物品：一类物品只能取一次，另一类物品可以取无限次，那么只需在对每个物品应用转移
动态规划 背包九讲 01背包的分组背包问题
林黛玉到拔垂杨柳的博客
08-31 315
分组背包问题 有 N 组物品和一个容量是 V 的背包。 每组物品有若干个，同一组内的物品最多只能选一个。 每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。 接下来有 N 组数据： 每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量； 每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分
背包DP问题（01背包+完全背包+分组背包+多重背包+混合背包+二维费用的背包）
柠檬的博客~~~
08-17 1317
背包DP问题 01背包问题 一、01背包问题 问题： 有N件物品和一个容量为V的背包。第i件物品的费用（即体积，下同）是w[i]，价值是c[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 基本思路： 　　这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。 　　用子问题定义状态：即f[i][v]表示前i件物品(部分或全部)恰放入一个容量为v的背包...
01背包，完全背包，多重背包，混合背包，二维费用背包，分组背包，背包问题求方案数
Cowry
09-04 883
1 01背包问题 有 NNN 件物品和一个容量是 VVV 的背包。每件物品只能使用 一次。 第 iii 件物品的体积是 viv_ivi​，价值是 wiw_iwi​。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 解析： 状态表示： f[i][j] 表示只看前 i 个物品，总体积是 j 的情况下的最大价值。 状态转移： 不选第 i 个物品，f[i][j] = f[...
01背包问题及二维费用背包问题
佛系更新
03-17 2046
AcWing算法提高课内容，本文讲解 动态规划 本篇包括以下题目： AcWing 423. 采药 AcWing 1024. 装箱问题 AcWing 278. 数字组合 AcWing 8. 二维费用的背包问题 AcWing 1020. 潜水员 AcWing 1022. 宠物小精灵之收服 写博客有哪里不完善的地方或者有哪里表达错误希望大家提出来，博主会立即改正！望大家海涵 本文需要先自修基础：背包问题 注：本文中的所有代码全部为优化后的代码，且不提供优化解释，解释请见：背包问题，其中有详细的解释。
二维费用背包问题的解题套路
hnjzsyjyj的专栏
08-08 707
二维费用的背包问题，即具有两种限制条件的背包问题，它是常见背包问题的一个简单的常见扩展。也就是说，常见的背包问题都会存在二维费用的扩展。如二维费用的0-1背包问题、二维费用的完全背包问题、二维费用的多重背包问题、二维费用的分组背包问题等。...
背包问题详解（01背包，完全背包，多重背包，分组背包）
走在努力路上的自己的博客
04-09 5909
有 N 件物品和一个容量是 V的背包。每件物品只能使用一次。第 i 件物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。输入格式第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。输出格式输出一个整数，表示最大价值。数据范围0
C++背包和完全背包讲解
最新发布
07-18
#### 01背包的二维数组实现 对于01背包问题，最直观的解决方法是使用二维数组来存储中间结果。其中，`f[i][j]`表示前`i`个物品恰好放入一个容量为`j`的背包可以获得的最大价值。具体实现代码如下： ```cpp #include...
01背包，部分背包，完全背包问题.docx
06-24
其核心思想是将问题分解为子问题，通过构建二维数组m[i][j]表示前i个物品放入容量为j的背包能得到的最大价值。状态转移方程为m[i][j] = max(m[i-1][j], m[i-1][j-w[i]] + v[i])，表示当前物品不放入或放入背包中，取...
beibaowenti.rar_01背包_01背包问题_01规划_knapsack c
09-21
在01背包问题中，我们可以用二维数组dp来表示子问题的状态，其中dp[i][w]表示在前i个物品中选择，且背包容量为w的情况下，能获得的最大价值。这个数组的初始化通常是dp[0][w] = 0，因为没有物品时，背包价值为0。 ...
树的递归遍历与递归序
不搞数学的汤老师
01-21 1087
树的遍历 void pre(Node head) { // 先序 if (head == null) return; printf("%c ", head.element); pre(head.left); pre(head.right); } void mid(Node head) { // 中序 if (head == null) return; mid(head.left); printf("%c ", head.element); mid(head.right); } void po
2022 年哈工大 854 算法大题
不搞数学的汤老师
12-27 1073
用三个栈 s1 s2 s3 实现队列 push：在队尾插入一个元素 pop：删除并返回队头元素 max：返回整个队列中最大的元素，要求时间复杂度 O(1)O(1)O(1) 可以直接使用操作栈的函数
计算机的表达式求值——逆波兰数
不搞数学的汤老师
09-13 899
波兰数与逆波兰数 波兰数解决的是这样的一个问题：如果操作符与操作数是固定的，则语法上不需要括号仍然能被无歧义地解析。 波兰数又称之为前缀表达式，逆波兰数又称之为后缀表达式。而日常使用的表达式则称为中缀表达式。 中缀表达式 小学老师告诉我们，一个表达式的构成包含操作符（加减乘除）、操作数和括号构成。如何无需括号的参与就能正确无误的解析这个表达式？这就是波兰数要解决的问题。 举个例子，如：(15/7−(1+1))∗3−(2+(1+1))(15 / 7 - (1 + 1)) * 3 - (2 + (1 + 1
详解 KMP 算法
不搞数学的汤老师
08-06 621
暴力匹配 S1：aabaabsaabaabaabsaabt 与 S2：aabaabsaabt 暴力匹配流程如下。 aabaabsaabaabaabsaabt ^ 从头开始匹配 aabaabsaabt ^ ------------------------------------------------------------------------ aabaabsaabaabaabsaabt ^ aabaabsaabt ^ 发生不匹配 -----------------
二维费用背包问题解析：从01到复数域的扩展
"二维费用的背包问题-安捷伦6位半万用表原理图" 二维费用的背包问题是一种扩展了传统背包问题的优化模型，其中每件物品具有两种不同的费用，即代价1和代价2。在选择物品时，需要同时考虑这两项代价，并且每种代价都...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值