背包九讲 c++实现完整代码

最新推荐文章于 2024-08-22 20:58:42 发布
最新推荐文章于 2024-08-22 20:58:42 发布
阅读量5.6k 收藏 31
点赞数 4
分类专栏： 数据结构与算法 文章标签： 背包九讲 动态规划 背包问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/desirepath/article/details/71679170
版权

原文链接：

http://love-oriented.com/pack/pack2alpha1.pdf

1. 01背包

1）题目：
有n件物品和一个容量为v的背包。
第i件物品的费用是c[i]，价值是w[i]。
求解将哪些物品装入背包可使价值总和最大
2）输入：
测试用例数 
物品数 背包大小 
n个物品的ci和wi
3）代码：
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxV 1000

int main(void) {
	int times, n, v, ci, wi;
	int f[maxV];
	freopen("1.txt", "r", stdin);
	cin >> times;
	while (times--) {
		memset(f, 0, sizeof(f));
		cin >> n >> v;
		for (int i = 0; i < n; i++) {
			cin >> ci >> wi;
			for (int j = v; j >= 0; j--) {
				if (j >= ci)
					f[j] = max(f[j - ci] + wi, f[j]);
			}
		}
		for (int i = 0; i <= v; i++) cout << f[i] << " ";
		cout << endl;
		cout << f[v] << endl;
	}
}

4）测试文件：
2
4 10
2 4
3 5
4 6
5 10

5 20
3 2
7 3
10 5
15 6
16 10


2. 完全背包

1）题目：
有n件物品和一个容量为v的背包，每种物品都有无限件可用。
第i种物品的费用是c[i]，价值是w[i]。
求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
2）输入：
测试用例数 
物品数 背包容量
n个物品的ci和vi
3）代码：
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
#define maxV 1000

int main(void) {
	int cases, n, v, ci, wi;
	int f[maxV];
	freopen("2.txt", "r", stdin);
	cin >> cases;
	while (cases--) {
		memset(f, 0, sizeof(f));
		cin >> n >> v;
		for (int i = 0; i < n; i++) {
			cin >> ci >> wi;
			for (int j = 0; j <= v; j++) {
				if (j >= ci)
					f[j] = max(f[j], f[j - ci] + wi);
			}
		}
		cout << f[v] << endl;
	}
}

4）测试文件：
2
4 10
2 4
3 5
4 6
5 10

5 20
3 2
7 3
10 5
15 6
16 10


3. 多重背包

1）题目：
有n种物品和一个容量为v的背包。
第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。
求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
2）输入：
测试用例数 
物品数 背包容量
n个物品的ni ci wi
3）代码：
#include <iostream>
#include <algorithm>
using namespace std;
#define maxV 1000

int f[maxV], v;

void ZeroOnePack(int ci, int wi) {
	for (int j = v; j >= 0; j--) 
		if (j >= ci)
			f[j] = max(f[j], f[j - ci] + wi);
}

void CompletePack(int ci, int wi) {
	for (int j = 0; j <= v; j++) 
		if (j >= ci)
			f[j] = max(f[j], f[j - ci] + wi);
}

void MultiplePack(int ni, int ci, int wi) {
	if (ni * ci >= v) {
		CompletePack(ci, wi);
		return;
	}
	int k = 1, amount = ni;
	while (k < ni) {
		ZeroOnePack(ci * k, wi * k);
		amount -= k;
		k *= 2;
	}
	ZeroOnePack(ci * amount, wi * amount);
}

int main(void) {
	int cases, n, ni, ci, wi;
	freopen("3.txt", "r", stdin);
	cin >> cases;
	while (cases--) {
		memset(f, 0, sizeof(f));
		cin >> n >> v;
		for (int i = 0; i < n; i++) {
			cin >> ni >> ci >> wi;
			MultiplePack(ni, ci, wi);
		}
		//for (int i = 0; i <= v; i++) cout << f[i] << " "; cout << endl;
		cout << f[v] << endl;
	}
}

4）测试文件：
2 
3 10
1 1 10
2 2 4
3 3 11

4 20
5 2 5
2 3 6
3 4 8
1 6 19


4. 混合三种背包

1）问题：
有的物品只可以取一次（01背包），有的物品可以取无限次（完全背包），有的物品可以取的次数有一个上限（多重背包）。
应该怎么求解呢？
2）输入：
测试用例数
物品数 背包容量
第i种物品的ni(无限次的标为-1) ci wi
3）代码：
#include <iostream>
#include <cstring>
using namespace std;
#define maxV 1000

int f[maxV], v;

void ZeroOnePack(int ci, int wi) {
	for (int j = v; j >= 0; j--) 
		if (j >= ci)
			f[j] = max(f[j], f[j - ci] + wi);
}

void CompletePack(int ci, int wi) {
	for (int j = 0; j <= v; j++) 
		if (j >= ci)
			f[j] = max(f[j], f[j - ci] + wi);
}

void MultiplePack(int ni, int ci, int wi) {
	if (ni * ci >= v) {
		CompletePack(ci, wi);
		return;
	}
	int k = 1, amount = ni;
	while (k < ni) {
		ZeroOnePack(ci * k, wi * k);
		amount -= k;
		k *= 2;
	}
	ZeroOnePack(ci * amount, wi * amount);
}

int main(void) {
	int cases, n, ni, ci, wi;
	freopen("4.txt", "r", stdin);
	cin >> cases;
	while (cases--) {
		memset(f, 0, sizeof(f));
		cin >> n >> v;
		for (int i = 0; i < n; i++) {
			cin >> ni >> ci >> wi;
			if (ni == 1) ZeroOnePack(ci, wi);
			else if (ni == -1) CompletePack(ci, wi);
			else MultiplePack(ni, ci, wi);
		}
		for (int i = 0; i <= v; i++) cout << f[i] << " "; cout << endl;
		cout << f[v] << endl;
	}
}

4）测试文件：
2
3 10
-1 1 2
2 2 5
1 3 7

4 20
3 2 5
4 4 6
-1 6 8
1 7 10


5. 二维费用的背包

1）问题：
对于每件物品，具有两种不同的费用；
选择这件物品必须同时付出这两种代价；
对于每种代价都有一个可付出的最大值（背包容量）。
问怎样选择物品可以得到最大的价值。
第i件物品所需的两种代价分别为a[i]和b[i]。
两种代价可付出的最大值（两种背包容量）分别为V和U。物品的价值为w[i]。
2）输入：
测试用例数
物品数 第一个背包容量v 第二个背包容量u
第i个物品的ai bi wi
3）代码：
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
#define maxV 1000
#define maxU 1000

int main(void) {
	int cases, n, v, u, ai, bi, wi;
	int f[maxV][maxU];
	freopen("5.txt", "r", stdin);
	cin >> cases;
	while (cases--) {
		memset(f, 0, sizeof(f));
		cin >> n >> v >> u;
		for (int i = 0; i < n; i++) {
			cin >> ai >> bi >> wi;
			for (int j = v; j >= 0; j--) {
				for (int k = u; k >= 0; k--) {
					if (ai <= j && bi <= k)
						f[j][k] = max(f[j][k], f[j - ai][k - bi] + wi);
				}
			}
		}
		cout << f[v][u] << endl;
	}
}
4）测试文件：
2
3 10 5
1 2 4
2 1 4
4 4 6

4 5 6
1 1 3
1 2 4
2 1 4
3 4 7



6. 分组背包

1）问题：
有n件物品和一个容量为v的背包。
第i件物品的费用是c[i]，价值是w[i]。
这些物品被划分为若干组，每组中的物品互相冲突，最多选一件。
求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
2）输入：
测试用例数 
物品数 背包容量 组数g(组号范围：0 ~ g-1)
第i件物品的ci wi gi(所属组号)
3）代码：
#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>

using namespace std;
#define maxV 1000
#define maxG 100
#define maxN 100

int main(void) {
	int cases, n, v, g, gi;
	int f[maxV];
	int ci[maxN], wi[maxN];
	freopen("6.txt", "r", stdin);
	cin >> cases;
	while (cases--) {
		memset(f, 0, sizeof(f));
		cin >> n >> v >> g;
		vector<vector<int> > gMap(g);
		for (int i = 0; i < n; i++) {
			cin >> ci[i] >> wi[i] >> gi;
			gMap[gi].push_back(i);
		}

		for (int i = 0; i < g; i++) {
			for (int j = v; j >= 0; j--) {
				for (int k = 0; k < gMap[i].size(); k++) {
					if (j >= ci[gMap[i][k]])
						f[j] = max(f[j], f[j - ci[gMap[i][k]]] + wi[gMap[i][k]]);
				}
			}
		}

		cout << f[v] << endl;
	}
}

4）测试文件：
2
4 10 2
3 5 0
4 6 0
2 7 1
1 6 1

5 10 3
1 3 0
2 4 0
3 5 1
4 7 1
5 8 2


7. 有依赖的背包

1）题目：
这种背包问题的物品间存在某种“依赖”的关系。
也就是说，i依赖于j，表示若选物品i，则必须选物品j。
为了简化起见，我们先设没有某个物品既依赖于别的物品，又被别的物品所依赖；
另外，没有某件物品同时依赖多件物品。
2）输入：
测试用例数 
物品数 背包大小
第i个物品的ci wi di(依赖物品的编号，-1为不依赖其他物品)
3）代码：
#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;
#define maxV 1000
#define maxG 100

int main(void) {
	int cases, n, v, ci[maxV], wi[maxV], di, f[maxV];
	freopen("7.txt", "r", stdin);
	cin >> cases;
	while (cases--) {
		memset(f, 0, sizeof(f));
		cin >> n >> v;
		
		// group[i]空表示i号物品有依赖，因此存放到其他组里
		// 只有一个元素表示i号物品既无依赖也不被依赖
		// 有多个元素表示i号物品被依赖，这里自己的编号i也被存放进group[i]
		vector<vector<int> > groups(n); 

		// 读入数据并储存起来
		for (int i = 0; i < n; i++) {
			cin >> ci[i] >> wi[i] >> di;
			if (di == -1) groups[i].push_back(i);
			else groups[di].push_back(i);
		}

		// 对每个有多个元素的组进行01背包
		for (int i = 0; i < n; i++) {
			if (groups[i].size() > 1) {
				vector<int> giOri; //group[i]的拷贝，排除i本身
				int newV = v - ci[i];

				// 复制group[i]中的元素，排除i
				for (int j = 0; j < groups[i].size(); j++) {
					if (groups[i][j] != i)
						giOri.push_back(groups[i][j]);
				}

				// 把等效物品组存入group[i]中
				groups[i].clear();
				groups[i].resize(newV + 1, 0);
				for (int j = 0; j < giOri.size(); j++) {
					for (int k = newV; k >= 0; k--) {
						if (ci[giOri[j]] <= k) {
							groups[i][k] = max(groups[i][k], groups[i][k - ci[giOri[j]]] + wi[giOri[j]]);
						}
					}
				}
			}
		}

		// 进行分组背包
		for (int i = 0; i < n; i++) {
			if (groups[i].size() == 0) continue;
			else if (groups[i].size() == 1) { // i物品无依赖且不被依赖
				for (int j = v; j >=0; j--) {
					if (j >= ci[i])
						f[j] = max(f[j], f[j - ci[i]] + wi[i]);
				}
			} else { // i物品被依赖, i组第k个物品的cost为k + ci[i], weight为group[i][k] + wi[i]
				for (int j = v; j >= 0; j--) { 
					for (int k = 0; k < groups[i].size(); k++) {
						if (j >= k + ci[i])
							f[j] = max(f[j], f[j - k - ci[i]] + groups[i][k] + wi[i]);
					}
				}
			}
		}
		
		cout << f[v] << endl;
	}
}

4）测试文件：
2
3 10
3 5 -1
4 6 0
7 10 0

4 15
4 1 -1
6 8 0
7 10 0
10 4 -1


8. 泛化物品

1）题目：
在背包容量为v的背包问题中，泛化物品是一个定义域为0..v中的整数的函数h，当分配给它的费用为v时，能得到的价值就是h(v)。
为了应用泛化物品思想，这里假设题目为：存在依赖关系树（简单起见，只有一个根节点），即有依赖的物品也可以被依赖，可结合原文7.3节来理解此句。
2）输入：
测试用例数
物品数 背包容量 根节点编号
第i个物品的ci wi di(依赖物品的编号，-1为不依赖其他物品)
3）代码：
#include <iostream>
#include <algorithm>
using namespace std;
#define maxN 100
#define maxV 1000

int n, v;
int cnt = 0;
int head[maxN];
int wi[maxN], ci[maxN];
int f[maxN][maxV];

struct Edge {
	int v, next;
} e[maxN - 1];

void addEdge(int u, int v) {
	e[cnt].v = v;
	e[cnt].next = head[u];
	head[u] = cnt++;
}

void treeDP(int u) {
	for (int i = ci[u]; i <= v; i++) {
		f[u][i] = wi[u];
	}
	for (int i = head[u]; i != -1; i = e[i].next) {
		int curr = e[i].v;
		treeDP(curr);
		for (int j = v; j >= 0; j--) {
			for (int k = j - ci[u]; k >= 0; k--) {
				f[u][j] = max(f[u][j], f[u][j - k] + f[curr][k]);
			}
		}
	}
}

int main(void) {
	int cases, root;
	freopen("8.txt", "r", stdin);
	cin >> cases;
	while (cases--) {
		cnt = 0;
		memset(head, -1, sizeof(head));
		memset(f, 0, sizeof(f));
		cin >> n >> v >> root;
		for (int i = 0; i < n; i++) {
			int di;
			cin >> ci[i] >> wi[i] >> di;
			addEdge(di, i);
		}
		treeDP(root);
		cout << f[root][v] << endl;
	}
}

4）测试文件：
2
5 5 0
1 2 -1
2 7 0
2 5 0
2 6 2
1 4 2

6 5 0
1 2 -1
1 3 0
2 3 0
2 4 0
2 7 2
3 10 2


9. 背包问题的变化

1）题目：
输出01背包的具体方案
2）输入：
同01背包
3）代码：
#include <iostream>
#include <algorithm>
using namespace std;
#define maxV 1000
#define maxN 100

int main(void) {
	int cases, n, v, ci[maxN], wi;
	int f[maxV];
	bool g[maxN][maxV]; //g[i][v]=0 表示没放i时的f(i, v)较大，
						//g[i][v]=1 表示放进i时的f(i, v)较大
	freopen("9.txt", "r", stdin);
	cin >> cases;
	while (cases--) {
		memset(f, 0, sizeof(f));
		memset(g, 0, sizeof(g));
		cin >> n >> v;
		for (int i = 0; i < n; i++) {
			cin >> ci[i] >> wi;
			for (int j = v; j >= 0; j--) {
				if (j >= ci[i]) {
					if (f[j - ci[i]] + wi > f[j]) {
						f[j] = f[j - ci[i]] + wi;
						g[i][j] = 1;
					}
				}
			}
		}

		int i = n - 1, j = v;
		while (i >= 0) {
			if (g[i][j] == 1) {
				cout << "选了" << i << endl;
				j -= ci[i];
			} else {
				cout << "没选" << i << endl;
			}
			i--;
		}
		cout << endl;
	}
}
4）测试文件：
2
4 10
2 4
3 5
4 6
5 10

5 20
3 2
7 3
10 5
15 6
16 10




desirepath
关注
专栏目录
背包算法（C++实现）
mycocoo的博客
12-08 467
#include<iostream> #include<stdlib.h> using namespace std; #define MaxNumber 100 int *Weight = new int[MaxNumber]; int *Value = new int[MaxNumber]; int MaxWeight; void sort(int length) { int num = 0; for (int i = 0; i < length; i++) { f
C++实现背包算法
weixin_54027333的博客
11-06 2511
背包算法—思想与实现 我们先来看一道题 问题描述： 有N件物品和一个容积为M的背包。第i件物品的体积为volume[i]，价值为worth[i]。求解将哪些物品装入背包可使价值总和最大。每种物品只有一件，可以选择放或者不放。（N<=3500,M<=13000） 输入格式： 第一行为物品数量N和背包容积M 每行依次输入第i件物品的价值和体积 样例输入： 3 10 3 4 2 6 6 7 样例输出： 6 思想: 这道题我们要考虑利益最大化。 下图是蓝色的线条我们的利益 我们只要先找到最大的利益
C++动态规划（背包问题）
最新发布
Archie28的博客
08-22 1208
c++动态规划（背包问题）
01背包问题算法源码（C++）
11-03
01背包问题算法的C++实现。 knapsack.cpp + knapsack.h
背包九讲--多重背包的原理及代码实现
20164225的博客
09-21 706
本文参考： https://blog.csdn.net/biubiupa233/article/details/78461741 多重背包：有n种物品与承重为m的背包。每种物品有有限件num[i]，每个物品都有对应的重量weight[i]与价值value[i]，求解如何装包使得价值最大。 首先这种可以把物品拆开，把相同的num[i]件物品 看成 价值跟重量相同的num[i]件不同的物品，那么...
0-1背包问题_算法设计C++
03-17
0-1背包问题_算法设计C++ 可以实现 大家分享学习
背包九讲，各种背包问题的分析
05-11
《背包问题九讲》是一篇全面讲解动态规划在背包问题上应用的文章，介绍了多种不同类型的背包问题及其解决方案。 1. 0-1背包问题：这是最基础的背包问题，每个物品只能选择放或不放，没有数量限制。问题的解决方案...
背包九讲-2.0
01-08
《背包九讲-2.0》是一本专注于动态规划中背包问题解析的教程，第二版在第一版的基础上进行了大量修订，修正了错误，并且用更加通俗易懂的语言重新阐述了背包问题的解决策略。该教程主要针对编程爱好者，尤其是那些对...
c++背包九讲之01背包
weixin_42579072的博客
11-22 1005
一、背包九讲总述 关于动态规划问题，最典型的就是背包九讲，先理解背包九讲后再总结关于动态规划的问题。 1、01背包问题 2、完全背包问题 3、多重背包问题 4、混合背包问题 5、二维费用的背包问题 6、分组背包问题 7、背包问题求方案数 8、求背包问题的方案 9、有依赖的背包问题 二、01背包问题 01背包（ZeroOnePack）: 有n件物品和一个容量为C的背包， 每种物品均只有一件，第i...
[AcWing]，背包九讲---过程推导+代码实现（全面）
duchenlong的博客
01-28 482
详细解释ACWing中的所有背包问题，从01背包，完全背包，混合背包，三种多重背包，组合背包，有依赖的背包，二维费用的背包，背包问题的方案数，最小字典序的方案问题，给出DP的推导过程+原理
背包九讲
08-09
《背包九讲》是一部关于计算机科学与算法设计的著作，主要聚焦于动态规划中的“背包问题”。在IT领域，动态规划是一种强大的问题解决方法，常用于优化和计算问题，尤其在处理具有重叠子问题和最优子结构的问题时非常...
背包九讲和代码
12-01
背包九讲和代码背包九讲和代码背包九讲和代码背包九讲和代码背包九讲和代码
0/1背包的c++代码实现
11-27
0/1背包问题，其中包括计算单目标的背包问题所获得的最大值
背包问题的C++代码
09-01
背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。相似问题经常出现在商业、组合数学，计算复杂性理论、密码学和应用数学等领域中。
算法——背包问题
05-03
背包问题（Knapsack problem）是组合优化领域的一类经典问题: 给定一个物品集合，每个物品具有一定重量以及一定的价值. 对于一个承载重量有限的背包，如何决定放入的物品，使得在背包承载的范围内获取所装物品的最大价值. 背包问题具有多种表现形式，其中最常见的当数0-1背包问题（0-1 knapsack problem），它规定了放入到背包中的物品的数目的表现形式，每种物品具有放入（且仅放入一次）或不放入两种形式，用0和1分别进行表示： 这里的 ，代表了第 个物品是否包含在背包当中， 表示第 个物品的价值， 表示第 个物品的重量， 表示背包的最大承载能力. 题目： 试用贪心算法和动态规划方法来解决0-1背包问题，采用所提供的数据集合. 作业需要提供实验报告，包括伪代码和运行代码，以及每个测试问题的运行时间、结果，如果无法在有限时间得到答案则为N.A.
C++代码背包算法
05-31
C++代码背包算法，忘记是哪道题了，不过代码都是一样的
01背包代码（c++）
tr990511的专栏
05-23 1613
五个物品的重量：2，2，6，5，4 每个物品的价值：6，3，5，4，6 #include int main () {     int C,n,j,i ;     int x[20];     int v[20][20];     int w[6]= {0,2,2,6,5,4};     int a[6]= {0,6,3,5,4,6};     C=10;     n=5;
HDU-1248 寒冰王座 （完全背包）
01-03 339
讲道理这题真是背包问题中的水题，第一次写背包如此轻松。 题目： 不死族的巫妖王发工资拉,死亡骑士拿到一张N元的钞票(记住,只有一张钞票),为了防止自己在战斗中频繁的死掉,他决定给自己买一些道具,于是他来到了地精商店前. 死亡骑士:”我要买道具!” 地精商人:”我们这里有三种道具,血瓶150块一个,魔法药200块一个,无敌药水350块一个.” 死亡骑士...
背包合集C++
再走一步
04-09 258
//多重背包 #include <cstdio> #include <iostream> #include <cstring> #include<algorithm> using namespace std; int main() { int p[101],h[101], c[101]; int dp[101]; int...
C++实现各类背包问题代码及解决方案
本文档主要介绍了C++编程语言中处理几种常见的背包问题的代码实现。背包问题是一类经典的优化问题，涉及在有限容量的容器中选择物品以最大化价值或满足特定条件。以下是文档中提到的主要知识点： 1. **01背包问题**...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值