背包问题的动态规划C++实现（01背包和完全背包）

最新推荐文章于 2024-05-29 22:07:59 发布
最新推荐文章于 2024-05-29 22:07:59 发布
阅读量1.5k 收藏 1
点赞数
分类专栏： 算法 文章标签： 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mingcaixiao/article/details/124352535
版权

0,1背包

为方便起见，令零件价值等于其长度

#include<iostream>
#include<vector>
#include<ctime>
#include<iomanip>
using namespace std;
void zeroOneKnapsack(vector<vector<int>>& path,vector<int>& result,
	const vector<int>& v, const vector<int>& w, int C) {

	size_t n = v.size();
	//记录路径的数组
	vector<vector<int>> p(n, vector<int>(C + 1));
	vector<int> f(C+1);

	//初始化
	for (size_t j = 0; j < C + 1; j++)
	{
		if (j >= w[0])
		{
			p[0][j] = 1;
			f[j] = w[0] ;
		}
	}

	for (size_t i = 1; i < n; i++) {
		for (int j = C; j >= w[i]; j--) {
			if (f[j] < f[j - w[i]] + v[i])
			{
				f[j] = f[j - w[i]] + v[i];
				p[i][j] = 1;
			}
		}
	}
	result = f;
	path = p;
}

vector<int> zeroOneKnapsackBacktrackPlan(const vector<int>& w,const vector<vector<int>>& path, const vector<int>& result)
{

	size_t n = path.size();
	size_t C = result.size()-1;

	vector<int>plan(n);

	int i = n-1;
	int j = C;
	while (i >= 0) {
		if (path[i][j]) {
			plan .at(i) = 1;
			j -= w[i];
		}
		i--;
	}
	return plan;
}

template <typename T>
void printVector(const vector<T>& v)
{
	for (auto it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

void printInfo(const vector<int>& weight, const vector<int>& value,const vector<int>& plan,const vector<int>& result)
{
	auto C = result.size()-1;
	auto n = weight.size();
	cout << "knapsack volume is:" << C << endl;
	cout << "weight:";
	printVector(weight);
	cout << "value:";
	printVector(value);
	cout << "solution:";
	printVector(plan);
	cout << "result:" << result[C] << endl;
	cout << endl;
}

int main(int argc, char* argv[])
{
	vector<vector<int>> weight
	{
		{20,80,30,70,23},
		{23,45,64,23,2},
		{1322,1900,345,235},
		{13,81,47,234,457,908,1423,453,2354,4200,4300},
		{1700,2300,354,677,4333,5647,435,809,234,457,908,1423,453,2354,4200,4300},
		{307,312,817,322,722,742,747,752,757,762,767,772,777,802,873,882,883,1073,1078,1083,1088,1093,1098,1103,1108,1113,1118,1123,1166,1326,562,572,577,582,587,592,597,602,607,612,617,622,722,742,747,752,757,762,767,772,777,802,873,882,552}
	};
	auto value = weight;
	vector<int>C = { 100,100,6000,6000,6000,6000};

	//0,1背包
	
    cout << "zeroOneKnapsack:" << endl;
	for (size_t i = 0; i < C.size(); i++)
	{
		clock_t startTime, endTime;
		vector<int> result;
		vector<vector<int>> path;
		vector<int> plan;
		

		startTime = clock();
		zeroOneKnapsack(path, result, value.at(i), weight.at(i), C.at(i));
		plan = zeroOneKnapsackBacktrackPlan(weight.at(i), path, result);
		endTime = clock();

		cout << setprecision(8);
		cout << "consume " << ((double)endTime - (double)startTime) / CLOCKS_PER_SEC << " seconds" << endl;
		printInfo(weight.at(i),value.at(i),plan,result);
		cout << "----------------------" << endl;
	}
}

函数zeroOneKnapsack求解背包问题

zeroOneKnapsackBacktrackPlan回溯获得方案

运行结果为

zeroOneKnapsack:
consume 0 seconds
knapsack volume is:100
weight:20 80 30 70 23
value:20 80 30 70 23
solution:1 1 0 0 0
result:100

----------------------
consume 0 seconds
knapsack volume is:100
weight:23 45 64 23 2
value:23 45 64 23 2
solution:1 1 0 1 1
result:93

----------------------
consume 0.001 seconds
knapsack volume is:6000
weight:1322 1900 345 235
value:1322 1900 345 235
solution:1 1 1 1
result:3802

----------------------
consume 0.001 seconds
knapsack volume is:6000
weight:13 81 47 234 457 908 1423 453 2354 4200 4300
value:13 81 47 234 457 908 1423 453 2354 4200 4300 
solution:1 1 1 1 0 0 1 0 0 1 0
result:5998

----------------------
consume 0.002 seconds
knapsack volume is:6000
weight:1700 2300 354 677 4333 5647 435 809 234 457 908 1423 453 2354 4200 4300
value:1700 2300 354 677 4333 5647 435 809 234 457 908 1423 453 2354 4200 4300 
solution:0 1 0 1 0 0 1 0 1 0 0 0 0 1 0 0
result:6000

----------------------
consume 0.004 seconds
knapsack volume is:6000
weight:307 312 817 322 722 742 747 752 757 762 767 772 777 802 873 882 883 1073 1078 1083 1088 1093 1098 1103 1108 1113 1118 1123 1166 1326 562 572 577 
582 587 592 597 602 607 612 617 622 722 742 747 752 757 762 767 772 777 802 873 882 552
value:307 312 817 322 722 742 747 752 757 762 767 772 777 802 873 882 883 1073 1078 1083 1088 1093 1098 1103 1108 1113 1118 1123 1166 1326 562 572 577 582 587 592 597 602 607 612 617 622 722 742 747 752 757 762 767 772 777 802 873 882 552
solution:1 1 1 1 0 0 0 0 1 0 1 1 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
result:6000

完全背包

完全背包只给出求解函数和回溯方案函数，其他信息和上面的一致

vector<int> completeKnapsackBacktrackPlan(const vector<int>& w, const vector<vector<int>>& path, int result)
{
	vector<int>plan(w.size());
	int i = path.size() - 1;
	int j = result;
	while (i >= 0) {
		if (path[i][j]) {
			plan.at(i) += 1;
			j -= w[i];
		}
		else
		{
			i--;
		}
	}
	return plan;
}

void completeKnapsack(vector<vector<int>>& path, vector<int>& result,
	const vector<int>& v, const vector<int>& w, int C)
{
	size_t n = v.size();
	//记录路径的数组
	vector<vector<int>> p(n, vector<int>(C + 1));
	vector<int> f(C + 1);
	//初始化
	for (int j = 0; j < C + 1; j++)
	{
		if (j /w[0]>=1)
		{
			p[0][j] = 1;
			f[j] = j/w[0]*w[0];
		}
	}

	for (int i = 1; i < n; i++) {
		for (int j = w[i]; j <= C; j++) {
			if (f[j] < f[j - w[i]] + v[i])
			{
				f[j] = f[j - w[i]] + v[i];
				p[i][j] = 1;
			}
		}
	}
	result = f;
	path = p;
}

运行结果如下所示

completeKnapsack:
consume 0 seconds
knapsack volumn is:100
weight:20 80 30 70 23
value:20 80 30 70 23
solution:5 0 0 0 0
result:100

----------------------
consume 0 seconds
knapsack volumn is:100
weight:23 45 64 23 2 
value:23 45 64 23 2
solution:4 0 0 0 4
result:100

----------------------
consume 0 seconds
knapsack volumn is:6000
weight:1322 1900 345 235
value:1322 1900 345 235
solution:2 0 7 4
result:5999

----------------------
consume 0.001 seconds
knapsack volumn is:6000
weight:13 81 47 234 457 908 1423 453 2354 4200 4300
value:13 81 47 234 457 908 1423 453 2354 4200 4300 
solution:393 11 0 0 0 0 0 0 0 0 0
result:6000

----------------------
consume 0 seconds
knapsack volumn is:6000
weight:1700 2300 354 677 4333 5647 435 809 234 457 908 1423 453 2354 4200 4300
value:1700 2300 354 677 4333 5647 435 809 234 457 908 1423 453 2354 4200 4300
solution:0 0 4 0 0 0 10 0 1 0 0 0 0 0 0 0
result:6000

----------------------
consume 0.005 seconds
knapsack volumn is:6000
weight:307 312 817 322 722 742 747 752 757 762 767 772 777 802 873 882 883 1073 1078 1083 1088 1093 1098 1103 1108 1113 1118 1123 1166 1326 562 572 577 
582 587 592 597 602 607 612 617 622 722 742 747 752 757 762 767 772 777 802 873 882 552
value:307 312 817 322 722 742 747 752 757 762 767 772 777 802 873 882 883 1073 1078 1083 1088 1093 1098 1103 1108 1113 1118 1123 1166 1326 562 572 577 582 587 592 597 602 607 612 617 622 722 742 747 752 757 762 767 772 777 802 873 882 552
solution:1 11 1 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
result:6000

----------------------

E:\cpp>cd "e:\cpp\" && g++ completeKnapsack.cpp -o completeKnapsack && "e:\cpp\"completeKnapsack
completeKnapsack:     
consume 0 seconds     
knapsack volumn is:100
weight:20 80 30 70 23 
value:20 80 30 70 23  
solution:5 0 0 0 0    
result:100

----------------------
consume 0 seconds     
knapsack volumn is:100
weight:23 45 64 23 2  
value:23 45 64 23 2
solution:4 0 0 0 4
result:100

----------------------
consume 0.001 seconds
knapsack volumn is:6000
weight:1322 1900 345 235
value:1322 1900 345 235
solution:2 0 7 4
result:5999

----------------------
consume 0.001 seconds
knapsack volumn is:6000
weight:13 81 47 234 457 908 1423 453 2354 4200 4300 
value:13 81 47 234 457 908 1423 453 2354 4200 4300 
solution:393 11 0 0 0 0 0 0 0 0 0
result:6000

----------------------
consume 0.003 seconds
knapsack volumn is:6000
weight:1700 2300 354 677 4333 5647 435 809 234 457 908 1423 453 2354 4200 4300
value:1700 2300 354 677 4333 5647 435 809 234 457 908 1423 453 2354 4200 4300
solution:0 0 4 0 0 0 10 0 1 0 0 0 0 0 0 0 
result:6000

----------------------
consume 0.004 seconds
knapsack volumn is:6000
weight:307 312 817 322 722 742 747 752 757 762 767 772 777 802 873 882 883 1073 1078 1083 1088 1093 1098 1103 1108 1113 1118 1123 1166 1326 562 572 577 
582 587 592 597 602 607 612 617 622 722 742 747 752 757 762 767 772 777 802 873 882 552
value:307 312 817 322 722 742 747 752 757 762 767 772 777 802 873 882 883 1073 1078 1083 1088 1093 1098 1103 1108 1113 1118 1123 1166 1326 562 572 577 582 587 592 597 602 607 612 617 622 722 742 747 752 757 762 767 772 777 802 873 882 552
solution:1 11 1 0 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
result:6000

参考文献

背包问题九讲

mingcaixiao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态规划解决01背包问题
01-17
01背包是在M件物品取出若干件放在空间为W的背包里，每件物品的体积为W1，W2至Wn，与之相对应的价值为P1,P2至Pn。01背包是背包问题中最简单的问题。动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。
#566. 完全背包问题(knapsack)
shulitian123456的博客
03-12 78
设有 nn 种物品，每种物品有一个重量及一个价值。但每种物品的数量是无限的，同时有一个背包，最大载重量为 MM，今从 nn 种物品中选取若干件(同一种物品可以多次选取)，使其重量的和小于等于 MM，而价值的和尽可能大。
【C++ 动态规划-01背包问题，一篇就够了】
最新发布
w2457771的博客
05-29 422
动态规划-01背包问题
动态规划」详解背包问题及实践（附C++代码）
BXA
05-10 4872
背包问题是一个经典的组合优化问题，它可以被抽象为一个把物品放入背包中的过程，以求最终背包中物品价值的最大化。0/1背包问题是一个经典的动态规划问题，指的是有n个物品和一个容量为W的背包，每个物品只能选择装入一次或不装入。在装入背包的物品总重量不能超过W的前提下，选择物品装入背包中，使得背包中物品的总价值最大。
c++算法----动态规划（背包专题）
qq_63763951的博客
05-02 3500
1.普通背包问题 2.完全背包问题 3.多重背包问题 1.普通背包问题 每到第i个位置就考虑是否拿第i个位置上的物品（当然也要考虑当前背包的体积是否能装得下这个物品），以此类推，直至到达最后一个物品的位置。 #include <iostream> #include <algorithm> using namespace std; /* * 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 *第 i 件物品的体积是 vi，价值是 wi。 *...
C++ DP算法，动态规划——背包问题（背包九讲）
小天狼星_布莱克 的博客
01-28 2339
有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物
动态规划 完全背包问题.cpp
10-13
动态规划之完全背包问题。 完全背包是在N种物品中选取若干件（同一种物品可多次选取）放在空间为V的背包里，每种物品的体积为C1，C2，…，Cn，与之相对应的价值为W1,W2，…，Wn.求解怎么装物品可使背包里物品总价值...
C++ 动态规划算法实现0-1背包问题
04-22
总的来说，这个C++实现的0-1背包问题动态规划算法不仅展示了如何利用动态规划解决问题，还提供了代码调试和测试的方法，是学习和理解动态规划算法的一个优秀实例。通过深入研究和实践，我们可以掌握这一重要的算法...
动态规划 01背包问题 程序和代码
01-31
你可以通过阅读和理解提供的代码，加深对动态规划的理解，并尝试将其应用到其他类似问题中，如完全背包问题、多重背包问题等。在实际应用中，动态规划也常用于求解最短路径、最长公共子序列等问题，其思想具有很强的...
动态规划 01背包问题 c++代码
10-13
动态规划之01背包问题，cpp示例代码，经测试，编译通过，可直接使用。 背包问题(Knapsack problem)是一种组合优化的NP完全问题。问题可以描述为：给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，...
基于C++和遗传算法解决背包问题.zip
05-10
而对于完全背包问题，物品数量可能大于背包容量，需要使用多位编码。在计算背包容量占用时，可以使用累积权重函数。 在实现过程中，需要注意处理边界条件，例如当背包容量不足以容纳所有物品时，应优先选取价值密度...
0-1背包问题(Knapsack Problem)-动态规划方法（C语言递归和迭代)
Jasonchen1224的博客
02-28 6367
背包问题 C语言递归 C语言迭代 动态规划方法
C++ 算法篇 动态规划----背包之一 01背包
流年的博客
12-21 6124
一、01背包 题目：有 N 件物品和一个容量为 V 的背包。第 i 件物品的费用是 w[i]，价值是 p[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 例，有3个物品，背包容量为10，如下： 二维解法： #include<bits/stdc++.h> using namespace std; int f[50][220]={...
算法-动态规划-背包问题-C++
weixin_43541510的博客
03-22 758
在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。
【动态规划】背包问题详解
青年有志
05-05 2471
01背包问题 输入 4 5 1 2 2 4 3 4 4 5 输出 8 题解 核心思路 1. 矩阵 f 初始化为全零，这样可以保证只要体积不超过 j 都能装入 f[i][j] : 即从前 i 个物品中选，总体积不超过 j 的方案数。 f[i - 1][j - v] 表示： 当前为要处理的物品 i， 当满足 j >= v 时， 当前物品可以装入， 计算装入后是否会使得总价值变大，所以需要从之前的 i - 1, j - v, 转移过来用来代表 f[i][j] 当背包容量够时： 选：f[i][j
01背包问题（c++）
weixin_62602974的博客
09-16 680
01背包问题是最经典的背包问题下面是我的代码，思路比较清晰。
2020-10-15
wingacd的博客
10-15 178
有 N 种物品和一个容量是 V 的背包。 第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。 接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤100 0<vi,wi,si≤100 输入样例 4 5 1
【动态规划专栏】-- 01 背包问题 -- 动态规划经典题型
weixin_64609308的博客
06-11 5447
4道《01背包问题》动态规划算法经典题型
C++算法初级11——01背包问题（动态规划2）
bj_zhb的博客
04-27 1017
医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。所以，当我们计算第i行时，完全可以将j从大到小枚举，这样在计算状态f(i,j)之前，数组f[j]中存储的是状态f[i−1,j]，更新完以后，其中，所有奇数行的状态填入f[1][j]中，所有偶数行的状态填入f[0][j]中，如下图。所以，我们维护一个二维状态f[i,j], 来表示前i个物品，放到体积为j的背包里，可以得到的最大价值。所以，整个动态规划的过程就是一个”填表“的过程。
完全背包问题动态规划c++代码
04-02
以下是完全背包问题的动态规划实现的C代码： ```c #include<stdio.h> #define MAXN 1000 //物品的最大数量 #define MAXV 1000 //背包的最大容量 int dp[MAXV+1]; //dp[i]表示容量为i的背包所能装下物品的最大价值 int v[MAXN]; //v[i]表示第i个物品的体积 int w[MAXN]; //w[i]表示第i个物品的价值 int n; //物品的数量 int m; //背包的容量 int main(){ scanf("%d %d",&n,&m); for(int i=1;i<=n;++i){ scanf("%d %d",&v[i],&w[i]); } for(int i=1;i<=m;++i){ for(int j=1;j<=n;++j){ if(v[j]<=i){ dp[i]=max(dp[i],dp[i-v[j]]+w[j]); } } } printf("%d",dp[m]); return 0; } ``` 注：本代码中使用了max函数，需要先进行定义，可以使用以下代码实现： ```c int max(int a,int b){ return a>b?a:b; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值