背包问题

最新推荐文章于 2024-06-17 00:06:23 发布
最新推荐文章于 2024-06-17 00:06:23 发布
阅读量1w 收藏 17
点赞数 6
分类专栏： 程序员代码面试指南
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongtao_6/article/details/93924799
版权

0-1背包问题

每件物品有且仅有一件。
在这里插入图片描述
在这里插入图片描述
动态规划的关键是建立一个动态规划表，上表图6.17部分有错误，下表为改正后的表。表的建立从左上角按行计算，直到右下角。行j代表可供选择的物品，2行表示：0,1,2号物品可供选择。列i代表背包空间。表中的每一个值表示，若背包有i剩余空间，在0-j号物品中选择，能获得的最大价值。
若放当前物品：总价值为当前物品价值+剩余空间能放的最大价值；若不放当前物品：则总价值为当前空间能放的最大价值（上一行的值）。
在这里插入图片描述

vector<bool> knasSack(int n, int c,int *weight,int *value)
{
	vector<vector <int>> maxValue(n + 1, vector<int>(c + 1, 0));
	vector<bool> result(n, false);
	
	for (int i = 1; i <= n; i++) 
	{
		for (int j = 1; j <= c; j++) 
		{
			if (i == 1) 
			{
				maxValue[i][j] = (weight[i-1] <= j ? value[i-1] : 0);
			}
			else 
			{
				int topValue = maxValue[i - 1][j];  // 上一个网格的值
				//int thisValue = (weight[i-1] <= j ?       // 当前商品的价值 + 剩余空间的价值
				//	(j - weight[i-1] > 0 ? value[i-1] + maxValue[i - 1][j - weight[i-1]] : value[i-1])
				//	: topValue);
				int thisValue = weight[i - 1] <= j ? value[i - 1] + maxValue[i - 1][j - weight[i - 1]] : topValue;
				// 返回 topValue和thisValue中较大的一个
				maxValue[i][j] = (topValue > thisValue ? topValue : thisValue);
			}
		}
	}
	printVec2i(maxValue);

	for (int i = n, j = c; i > 0; i--) {
		if (maxValue[i][j] > maxValue[i - 1][j]) 
		{
			result[i - 1] = true;
			j = j - weight[i-1];
		}
	}
	return result;
}

0-1背包扩展：背包必须装满

在初始化时不能初始化为0，而要初始化为错误状态。在赋值时也加入对错误状态的判断。

vector<bool> knasSack_full(int n, int c, int *weight, int *value)
{
	vector<vector <int>> maxValue(n + 1, vector<int>(c + 1, -1));
	vector<bool> result(n, false);

	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= c; j++)
		{
			if (i == 1)
			{
				maxValue[i][j] = (weight[i - 1] == j ? value[i - 1] : -1);
			}
			else
			{
				int topValue = maxValue[i - 1][j];  // 上一个网格的值
				int thisValue = -1;
				if (weight[i - 1] == j)	thisValue = value[i - 1];
				if (weight[i - 1] < j)
				{
					if (maxValue[i - 1][j - weight[i - 1]] == -1)	thisValue = -1;
					else thisValue = value[i - 1] + maxValue[i - 1][j - weight[i - 1]];
				}
				// 返回 topValue和thisValue中较大的一个
				maxValue[i][j] = (topValue > thisValue ? topValue : thisValue);
			}
		}
	}
	printVec2i(maxValue);

	for (int i = n, j = c; i > 0; i--) {
		if (maxValue[i][j] > maxValue[i - 1][j])
		{
			result[i - 1] = true;
			j = j - weight[i - 1];
		}
	}
	return result;
}

多重背包问题

物品有指定件，只需用num数组对weight和value进行重新初始化即可。

int knasSack_kTimes(int n, int c, int *weight, int *value, int *num)
{
	vector<int> weightVec;
	vector<int> valueVec;
	for (int i = 0; i < n; i++)
	{
		while (num[i]--)
		{
			weightVec.push_back(weight[i]);
			valueVec.push_back(value[i]);
		}
	}
	/*
	.......
	.......
	.......
	*/
	return 0;
}

完全背包问题

物品件数有无穷多，初始化时从右向左初始化即可。加入变量times表示放了几件当前物品。

int knasSack_nTimes(int n, int c, int *weight, int *value)
{
	vector<vector <int>> maxValue(n + 1, vector<int>(c + 1, 0));
	vector<bool> result(n, false);

	for (int i = 1; i <= n; i++)
	{
		for (int j = c; j >= 1; j--)
		{
			if (i == 1)
			{
				maxValue[i][j] = (j / weight[i - 1] > 0 ? value[i - 1] * (int)(j / weight[i - 1]) : 0);
			}
			else
			{
				int topValue = maxValue[i - 1][j];  // 上一个网格的值
				int times = j / weight[i - 1];
				int thisValue = 0;
				if (times > 0)
				{
					for (int k = 1; k <= times; k++)
					{
						thisValue = value[i - 1] * k + maxValue[i - 1][j - weight[i - 1] * k] > thisValue ? value[i - 1] * k + maxValue[i - 1][j - weight[i - 1] * k] : thisValue;
					}
				}
				// 返回 topValue和thisValue中较大的一个
				maxValue[i][j] = (topValue > thisValue ? topValue : thisValue);
			}
		}
	}
	printVec2i(maxValue);

	return maxValue[n][c];
}

运行结果

分别为0-1背包问题，0-1背包问题扩展，完全背包问题的运行结果

在这里插入图片描述

完整代码

#include <iostream>
#include <vector>
#include "a_arrayAndMatrix.h"

using namespace std;

vector<bool> knasSack(int n, int c, int *wight, int *value);
vector<bool> knasSack_full(int n, int c, int *weight, int *value);
int knasSack_kTimes(int n, int c, int *weight, int *value, int *num);
int knasSack_nTimes(int n, int c, int *weight, int *value);

int main()
{
	int *weight = new int[5]{ 2,2,6,5,4 };
	int *value = new int[5]{ 6,3,5,4,6 };
	int n = 5;
	int c = 10;
	int maxVal = 0;
	vector<bool> result = knasSack(n, c, weight, value);
	
	for (int i = 0; i < result.size(); i++)
	{
		if (result[i])
		{
			maxVal += value[i];
		}
	}
	cout << maxVal << endl;

	maxVal = 0;
	vector<bool> result2 = knasSack_full(n, c, weight, value);
	for (int i = 0; i < result2.size(); i++)
	{
		if (result2[i])
		{
			maxVal += value[i];
		}
	}
	cout << maxVal << endl;

	cout << knasSack_nTimes(n, c, weight, value) << endl;

	system("pause");
	return 0;
}

vector<bool> knasSack(int n, int c,int *weight,int *value)
{
	vector<vector <int>> maxValue(n + 1, vector<int>(c + 1, 0));
	vector<bool> result(n, false);
	
	for (int i = 1; i <= n; i++) 
	{
		for (int j = 1; j <= c; j++) 
		{
			if (i == 1) 
			{
				maxValue[i][j] = (weight[i-1] <= j ? value[i-1] : 0);
			}
			else 
			{
				int topValue = maxValue[i - 1][j];  // 上一个网格的值
				//int thisValue = (weight[i-1] <= j ?       // 当前商品的价值 + 剩余空间的价值
				//	(j - weight[i-1] > 0 ? value[i-1] + maxValue[i - 1][j - weight[i-1]] : value[i-1])
				//	: topValue);
				int thisValue = weight[i - 1] <= j ? value[i - 1] + maxValue[i - 1][j - weight[i - 1]] : topValue;
				// 返回 topValue和thisValue中较大的一个
				maxValue[i][j] = (topValue > thisValue ? topValue : thisValue);
			}
		}
	}
	printVec2i(maxValue);

	for (int i = n, j = c; i > 0; i--) {
		if (maxValue[i][j] > maxValue[i - 1][j]) 
		{
			result[i - 1] = true;
			j = j - weight[i-1];
		}
	}
	return result;
}

vector<bool> knasSack_full(int n, int c, int *weight, int *value)
{
	vector<vector <int>> maxValue(n + 1, vector<int>(c + 1, -1));
	vector<bool> result(n, false);

	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= c; j++)
		{
			if (i == 1)
			{
				maxValue[i][j] = (weight[i - 1] == j ? value[i - 1] : -1);
			}
			else
			{
				int topValue = maxValue[i - 1][j];  // 上一个网格的值
				int thisValue = -1;
				if (weight[i - 1] == j)	thisValue = value[i - 1];
				if (weight[i - 1] < j)
				{
					if (maxValue[i - 1][j - weight[i - 1]] == -1)	thisValue = -1;
					else thisValue = value[i - 1] + maxValue[i - 1][j - weight[i - 1]];
				}
				// 返回 topValue和thisValue中较大的一个
				maxValue[i][j] = (topValue > thisValue ? topValue : thisValue);
			}
		}
	}
	printVec2i(maxValue);

	for (int i = n, j = c; i > 0; i--) {
		if (maxValue[i][j] > maxValue[i - 1][j])
		{
			result[i - 1] = true;
			j = j - weight[i - 1];
		}
	}
	return result;
}

int knasSack_kTimes(int n, int c, int *weight, int *value, int *num)
{
	vector<int> weightVec;
	vector<int> valueVec;
	for (int i = 0; i < n; i++)
	{
		while (num[i]--)
		{
			weightVec.push_back(weight[i]);
			valueVec.push_back(value[i]);
		}
	}
	/*
	.......
	.......
	.......
	*/
	return 0;
}

int knasSack_nTimes(int n, int c, int *weight, int *value)
{
	vector<vector <int>> maxValue(n + 1, vector<int>(c + 1, 0));
	vector<bool> result(n, false);

	for (int i = 1; i <= n; i++)
	{
		for (int j = c; j >= 1; j--)
		{
			if (i == 1)
			{
				maxValue[i][j] = (j / weight[i - 1] > 0 ? value[i - 1] * (int)(j / weight[i - 1]) : 0);
			}
			else
			{
				int topValue = maxValue[i - 1][j];  // 上一个网格的值
				int times = j / weight[i - 1];
				int thisValue = 0;
				if (times > 0)
				{
					for (int k = 1; k <= times; k++)
					{
						thisValue = value[i - 1] * k + maxValue[i - 1][j - weight[i - 1] * k] > thisValue ? value[i - 1] * k + maxValue[i - 1][j - weight[i - 1] * k] : thisValue;
					}
				}
				// 返回 topValue和thisValue中较大的一个
				maxValue[i][j] = (topValue > thisValue ? topValue : thisValue);
			}
		}
	}
	printVec2i(maxValue);

	return maxValue[n][c];
}
Liickia
关注
  • 6
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
动态规划专题——背包问题
⚡
02-13 3万+
详解四种背包：01背包、完全背包、多重背包、分组背包。
背包问题Matlab求解
05-28
标题中的“背包问题Matlab求解”指的是使用Matlab编程解决经典的组合优化问题——背包问题。背包问题是一个在有限的背包容量下，选择物品以最大化总价值的问题。它广泛应用于资源分配、项目选择等领域。 首先，我们...
【动态规划】01背包问题（通俗易懂，超基础讲解）
热门推荐
Yngz_Miao的博客
08-24 43万+
问题描述 有n个物品，它们有各自的体积和价值，现有给定容量的背包，如何让背包里装入的物品具有最大的价值总和？ 为方便讲解和理解，下面讲述的例子均先用具体的数字代入，即：eg：number＝4，capacity＝8 i（物品编号） 1 2 3 4 w（体积） 2 3 4 5 v（价值） 3 4 5 6 总...
背包问题详解
m0_72674633的博客
06-16 1043
背包问题详解
DP：01背包问题
最新发布
weixin_51142926的博客
06-17 2884
背包问题是⼀种组合优化的NP完全问题。 本质上是为了找出“带有限制条件的组合最优解”
01背包问题
ccc369639963的博客
01-19 1万+
01背包问题 商店的货架上摆放着不同重量和价值的商品，一个小偷在商店行窃，他携带的背包只能装固定重量的商品。装哪些商品才能获得最大的收益呢？在限定条件内找到最佳的物品组合，这样的问题统称为背包问题。 根据限定的条件不同，背包问题还可以细分： 部分背包问题：所有物品是可再分的，即允许将某件物品的一部分（例如 1/3）放入背包； 0-1 背包问题：所有物品不可再分，要么整个装入背包，要么放弃，不允许出现“仅选择物品的 1/3 装入背包”的情况； 完全背包问题：不对每一件物品的数量做限制，同一件物品可以选择多个装
动态规划之背包问题（01背包问题、完全背包问题、多重背包问题 I、多重背包问题 II 、分组背包问题）
小羊的博客
03-30 5万+
动态规划之背包问题（01背包问题、完全背包问题、多重背包问题 I、多重背包问题 II 、分组背包问题）
背包问题leetcode
Hello World程序员的博客
08-02 1314
问题一：分割等和子集（LeetCode 416） 416. 分割等和子集 //给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。 // // 注意: // // // 每个数组中的元素不会超过 100 // 数组的大小不会超过 200 // // // 示例 1: // // 输入: [1, 5, 11, 5] // //输出: true // //解释: 数组可以分割成 [1, 5, 5] 和 [11]. // // // // // 示.
leetcode——背包问题汇总
Michael_Jay的博客
12-24 2771
本篇文章汇总了leetcode常见的0-1背包问题和完全背包问题。
完全背包问题
weixin_57023347的博客
08-02 1万+
概念： 完全背包问题一般是指：有N件物品和一个能背重量为W的背包，第i件物品的重量为weight[i],价值为value[i]。每件物品有无限个(也就是可以放入背包多次），求怎样可以使背包物品价值总量最大。 完全背包与01背包问题的区别在于01背包物品只有一个，完全背包有无数个。 ...
Python 背包问题
小嗷犬的博客
07-07 2673
背包问题（Knapsack Problem）是一类常见的组合优化问题。其问题描述为：给定一个固定大小、能够携重 WW 的背包，以及一组有价值和重量的物品，找出一个最佳解决方案，使得装入背包的物品总重量不超过 WW，且总价值最大。
3-增量背包问题四类实例
09-03
增量背包问题（Incremental Knapsack Problem，IKP）是组合优化领域中的一个经典问题，源于实际生活中的资源分配和决策制定。在这个问题中，我们有一组物品，每种物品都有一个价值和一个重量，以及一个固定数量的...
01背包问题_01背包问题_
10-04
01背包问题是一种经典的组合优化问题，广泛应用于资源分配、任务调度等领域。在这个问题中，我们有一个容量为W的背包，以及n件物品，每件物品都有一个重量w[i]和一个价值v[i]。目标是选取不超过背包容量的物品，使得...
背包问题介绍背包问题.zip
03-21
【背包问题】是一种经典的组合优化问题，在计算机科学和运筹学中有着广泛的应用。它源自于实际生活中的物品装箱问题，例如在有限的行李箱空间内如何选择物品以达到最大价值或最小重量。在数学建模中，背包问题通常...
python基于递归解决背包问题详解
09-19
在计算机科学中，背包问题是一种经典的优化问题，它涉及到如何在有限的容量内选择最有价值的物品。在Python中，我们可以使用递归方法来解决这个问题。递归是一种强大的编程技术，它通过函数自身调用来解决问题，特别...
背包问题介绍1.zip
03-21
背包问题是一种经典的优化问题，在计算机科学，特别是运筹学和算法设计中占有重要地位。它源于实际生活中的物品装箱问题，例如如何在有限的背包容量内装入最有价值的物品。这个问题通常被用来模拟资源分配、项目选择...
背包问题九讲html版本
03-25
**背包问题概述** 背包问题是一种经典的优化问题，广泛应用于计算机科学和运筹学领域，特别是在算法设计和组合优化中占有重要地位。它通常涉及到在给定容量限制的情况下，选择物品以最大化价值或满足某些目标。这个...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值