动态规划小结——背包问题

最新推荐文章于 2025-05-26 15:58:30 发布
原创 最新推荐文章于 2025-05-26 15:58:30 发布 · 1.3k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#uva #动态规划

本文详细介绍了动态规划在解决背包问题中的应用，包括完全背包问题和0-1背包问题。完全背包问题中，每种物品无限，目标是最大化价值。0-1背包问题增加了物品限制，每种仅有一个，同样追求最大价值。文章提供了状态转移方程及相应代码实现，探讨了不同的状态定义对枚举顺序的影响，并讨论了降维优化的可能性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

背包问题是动态规划的经典问题，所有初次学习动态规划都会讲述这个经典问题。因此，有必要弄清跟背包问题的所有分析过程并熟练掌握各种类型的代码。

一，完全背包问题

1.问题描述：有n种物品，每种物品有无限多个，第i个物品重量是wi，价值是vi，从这些物品中挑选总重量不超过W的物品，求出挑选物品价值的最大值。

   限制条件：1≤n≤100,1≤wi,vi≤100,1≤W≤10000

2.解题思路：本题类似于“硬币问题”，硬币问题只要求凑够相应的面值，这里只不过多了一个新的属性——价值，即不仅要凑够重量，还要使得价值尽可能大。按照动态规划的分析思路，先定义状态d(j)：剩余重量为j时的最大价值。那么如果当前使用了第i个物品（如果可以用的话），状态变转移到j-w[i]，而价值变为d[j-w[i]]+v[i]，因此状态转移方程如下：

d[j]=max(d[j],d[j-w[i]]+v[i]);(0≤i＜n)

这个过程中随着物品的增多，剩余的重量在逐渐减小。

3.代码：

（1）不包含打印路径

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<functional>
using namespace std;

#define maxn 1000
#define rep(i,n) for(int i=0;i<(n);i++)
int d[maxn];
int w[maxn],v[maxn];
int n, W;
int dp(int j)
{
	int&ans = d[j];
	if (ans>0)return ans;
	for (int i = 0; i < n;i++)
	if (j >= w[i])
		ans = max(ans, dp(j-w[i]) + v[i]);
	return ans;
}
int main()
{
	//freopen("test.txt", "r", stdin);
	scanf("%d%d", &n, &W);
	rep(i, n)
		scanf("%d", w + i);
	rep(i, n)
		scanf("%d", v + i);
	dp(W);//从状态W开始，走到状态0
	cout << d[W] << endl;
	return 0;
}

（2）包含打印路径

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<functional>
using namespace std;

#define maxn 1000
#define rep(i,n) for(int i=0;i<(n);i++)
int d[maxn];
int w[maxn],v[maxn];
int n, W;
int dp(int j)
{
	int&ans = d[j];
	if (ans>0)return ans;
	for (int i = 0; i < n;i++)
	if (j >= w[i])
		ans = max(ans, dp(j-w[i]) + v[i]);
	return ans;
}
void print_ans(int j)
{
	for (int i = 0; i < n;i++)
	if (j >= w[i] && d[j] == d[j - w[i]] + v[i])
	{
		printf("%d ", i);
		print_ans(j - w[i]);
		break;
	}
}
int main()
{
	//freopen("test.txt", "r", stdin);
	scanf("%d%d", &n, &W);
	rep(i, n)
		scanf("%d", w + i);
	rep(i, n)
		scanf("%d", v + i);
	dp(W);//从状态W开始，走到状态0
	cout << d[W] << endl;
	print_ans(W);//打印所用物品的序号
	puts("");
	return 0;
}


二，0-1背包问题

1.问题描述：有n种物品，每种只有一个，，第i个物品重量是wi，价值是vi，从这些物品中挑选总重量不超过W的物品，求出挑选物品价值的最大值。

   限制条件：1≤n≤100,1≤wi,vi≤100,1≤W≤10000

2.解题思路：现在的问题又增加了一个限制条件——每种物品的个数，可以发现，原来的状态转移方程已经不适用了，因为只凭借“剩余重量的大小”无法得知每个物品是否用过，因此需要修改原来定义的状态，使得以后的决策可以有序化。

想象所有的物品按照序号摆成一排，现在，定义d(i,j)表示当前正在第i个物品处，背包的剩余容量为j时的最大价值。显然，这时的决策有两个：（1）不使用物品i；（2）使用物品i；因此，状态转移方程如下：

d(i,j)=max(d(i+1,j),d(i+1,j-w[i])+v[i]);(j≥w[i])

边界：d(n-1,j)=0;

上式中，i要逆序枚举，因为公式中i时候的状态是由i+1时候的得到的。上式中的j随着i的减小而增大，这也不难由公司看出。最后的答案是d[0][W]，这样代码便不难写出。

3.代码：

（1）不包含打印解

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<functional>
using namespace std;

#define maxn 1000
#define rep(i,n) for(int i=0;i<(n);i++)
int d[maxn][maxn];
int w[maxn],v[maxn];
int n, W;

int main()
{
	//freopen("test.txt", "r", stdin);
	memset(d, -1, sizeof(d));
	scanf("%d%d", &n, &W);
	rep(i, n)
		scanf("%d", w + i);
	rep(i, n)
		scanf("%d", v + i);
	for (int i = n - 1; i >= 0;i--)//i逆序枚举，由递推公式决定
	for (int j = 0; j <= W; j++)//j的顺序无所谓
	{
		d[i][j] = (i == n - 1 ? 0 : d[i + 1][j]);
		if (j >= w[i])
			d[i][j] = max(d[i][j], d[i + 1][j - w[i]] + v[i]);
	}
	printf("%d\n", d[0][W]);
	return 0;
}

（2）包含打印解

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<functional>
using namespace std;

#define maxn 1000
#define rep(i,n) for(int i=0;i<(n);i++)
int d[maxn][maxn];
int w[maxn],v[maxn];
int vis[maxn];
int n, W;

int main()
{
	//freopen("test.txt", "r", stdin);
	memset(d, -1, sizeof(d));
	scanf("%d%d", &n, &W);
	rep(i, n)
		scanf("%d", w + i);
	rep(i, n)
		scanf("%d", v + i);
	for (int i = n - 1; i >= 0; i--)//i逆序枚举，由递推公式决定
	for (int j = 0; j <= W; j++)//j的顺序无所谓
	{
		d[i][j] = (i == n - 1 ? 0 : d[i + 1][j]);
		if (j >= w[i])
		d[i][j] = max(d[i][j], d[i + 1][j - w[i]] + v[i]);
	}
	printf("%d\n", d[0][W]);
	printf("Solutions :");//打印已经选择的物品
	int R = W;
	for (int i = 0; i < n;i++)
	for (int j = R; j >= 0;j--)
	if (d[i][j] == d[i + 1][j])break;
	else if (j >= w[i] && d[i][j] == d[i + 1][j - w[i]] + v[i])
	{
		printf(" %d", i);
		R -= w[i];
		break;
	}
	printf("\n");
	return 0;
}


三，0-1背包问题的规划方向

刚刚的状态d(i,j)的定义是： 当前正在第i个物品处，背包的剩余容量为j时的最大价值。这样的定义导致了枚举i时必须逆序。其实还有一种“对称”的状态定义：当前正在第i个物品处，背包的总容量为j时的最大价值。按照这样的定义，不难得到如下的状态转移方程：

d(i,j)=max(d(i-1,j),d(i-1,j-w[i])+v[i])(j≥w[i]);

边界：d(0,j)=0;

按照上式，如果选择了物品i，那么在i-1处背包的容量必须是j-w[i]，这样才能装下i物品。由上式可知，i必须顺序枚举，因为i处的状态是由i-1处的状态得到的。而且j随着i的增大而增大，这和之前说的剩余容量在逐渐减小是一致的。最终的答案是d(n-1,W)代码与上面的类似。

3.代码：

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<functional>
using namespace std;

#define maxn 1000
#define rep(i,n) for(int i=0;i<(n);i++)
int d[maxn][maxn];
int w[maxn],v[maxn];
int vis[maxn];
int n, W;

int main()
{
	//freopen("test.txt", "r", stdin);
	memset(d, -1, sizeof(d));
	scanf("%d%d", &n, &W);
	rep(i, n)
		scanf("%d", w + i);
	rep(i, n)
		scanf("%d", v + i);
	for (int i = 0; i < n; i++)//i顺序枚举，由递推公式决定
	for (int j = 0; j <= W; j++)//j的顺序无所谓
	{
		d[i][j] = (i == 0 ? 0 : d[i - 1][j]);
		if (j >= w[i])
		d[i][j] = max(d[i][j], d[i - 1][j - w[i]] + v[i]);
	}
	printf("%d\n", d[n - 1][W]);
	return 0;
}


其实，这种对称的定义方法还有一个额外的好处，就是允许边读入边计算，而不必把w,v保存下来。

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<functional>
using namespace std;

#define maxn 1000
#define rep(i,n) for(int i=0;i<(n);i++)
int d[maxn][maxn];
int w, v;
int vis[maxn];
int n, W;

int main()
{
	//freopen("test.txt", "r", stdin);
	memset(d, -1, sizeof(d));
	scanf("%d%d", &n, &W);
	for (int i = 0; i < n; i++)//i顺序枚举，由递推公式决定
	{
		scanf("%d%d", &w, &v);//读入第i个物品的重量，价值
		for (int j = 0; j <= W; j++)
		{
			d[i][j] = (i == 0 ? 0 : d[i - 1][j]);
			if (j >= w)d[i][j] = max(d[i][j], d[i - 1][j - w] + v);
		}
	}
	printf("%d\n", d[n - 1][W]);
	return 0;
}


不仅如此，甚至可以把d数组降维，将其变成一维数组。利用原来的结果产生新的结果，节约内存空间。这是因为在更新d(i,j)之前，它保存的就是上一次刚刚算过的d(i-1,j)的值。同理，如果j要逆序枚举，d(i,j-w[i])保存的也是上次刚刚算过的d(i-1,j-w[i])的值。因此，忽略i，即可实现降维。

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<functional>
using namespace std;

#define maxn 1000
#define rep(i,n) for(int i=0;i<(n);i++)
int d[maxn];
int w, v;
int vis[maxn];
int n, W;

int main()
{
	freopen("test.txt", "r", stdin);
	memset(d, 0, sizeof(d));//将d数组初始化为0
	scanf("%d%d", &n, &W);
	for (int i = 0; i < n; i++)//i顺序枚举，由递推公式决定
	{
		scanf("%d%d", &w, &v);//读入第i个物品的重量，价值
		for (int j = W; j >= 0;j--)
		if (j >= w)
			d[j] = max(d[j], d[j - w] + v);
	}
	printf("%d\n", d[W]);
	return 0;
}

上述代码也被称为“滚动数组”，正是因为它相当于在不断地刷新之前的结果。但这种方法容易产生bug，而且很难打印解。当动态规划结束后，只有最后一个阶段的值，而没有前面的值。因此这种方法应该谨慎使用。




C++ DP算法，动态规划——背包问题（背包九讲）
小天狼星_布莱克 的博客
01-28 2614
有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci​，得到的价值是Wi​。求解将哪些物品装入背包可使价值总和最大。有N件物
动态规划——01背包问题（力扣416：分割等和子集）
qq_40472852的博客
11-26 716
前言 我们在前面进行了总结： 一个重要的判断一道题是否可用01背包问题去分析的条件是：有N个物体， 每个物体只能被选择一次， 而且只有选与不选两种情况 满足01背包问题的题目， 其状态可以用二维动态数组来表示， 一个变量表示背包容积， 另一个变量表示物品编号（一般可以用滚动数组进行优化， 不过具体也要看状态转移方程） 状态转移方程的考量只需从一个物品选与不选， 即面对第i个物品 当前容积若是大于第i个物品的重量， 那么就是选与不选的价值进行比较 若是小于第i个物品的重量， 那就只能不选 ..
动态规划背包问题总结
zj
08-24 1504
文章目录概念的区别0-1背包二维dp一维dp完全背包二维dp一维dp 参考：背包九讲（度娘自行搜索） 概念的区别 题目的详细阐述就不说了，可以到：题库 - AcWing去看。 只需要明白一点，0-1背包的每个物品只有选 / 不选两种选项，而完全背包的每个物品数量无限，想选多少个都可以。 0-1背包 先举个0-1背包的例子：494. 目标和 - 力扣（LeetCode） 这道题并不是直白的0-1背包问题，需要先转化一下： 所有的数先分成两种： 符号为正的数的总和设为一个背包的容量x， 符号为负的数的总和设
【动态规划】完全背包问题
weixin_43249938的博客
08-03 361
【动态规划】完全背包问题 贵有恒，何必三更起五更眠；最无益，莫过一日曝十日寒。 【动态规划】完全背包问题 时间限制: 1 Sec内存限制: 64 MB 题目描述 话说张琪曼和李旭琳又发现了一处魔法石矿（运气怎么这么好？各种嫉妒羡慕恨啊），她们有一个最多能装m公斤的背包，现在有n种魔法石，每种的重量分别是W1，W2，…，Wn，每种...
动态规划（7）：背包问题
最新发布
分享一些感兴趣的技术方面
05-26 950
背包问题动态规划解法综述 背包问题是动态规划的经典问题，主要包括01背包、完全背包、多重背包和分组背包四种类型。01背包是最基础形式，每种物品只能选或不选，通过状态转移方程和空间优化（逆向遍历）实现高效求解。完全背包允许物品无限次选取，采用正向遍历策略。多重背包限定物品选取次数，可通过二进制优化转化为01背包问题。分组背包则要求每组最多选一件物品，需遍历组内所有物品寻找最优解。这些算法在资源分配、投资决策等实际问题中有广泛应用，是动态规划的重要基础。掌握其核心状态转移思想和空间优化技巧，能有效解决各类约束条
动态规划---背包问题总结
StubbornAccepted的博客
10-20 465
背包问题： 有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w 和价值 v。 定义一个二维数组 dp 存储最大价值，其中 dp[i][j] 表示前 i 件物品体积不超过 j 的情况下能达到的最大价值。设第 i 件物品体积为 w，价值为 v，根据第 i 件物品是否添加到背包中，可以分两种情况讨论： 第 i 件物品没添加到背包，总体积不超过 j 的前 i 件物品的最...
动态规划之背包问题总结
myblog
11-20 976
01背包 简介：01背包是一个经典的问题，本文总结了四种01背包的解法
**动态规划之01背包问题与背包问题衍生详解（个人小结思考）**
qq_47680775的博客
01-04 588
动态规划之01背包问题与背包问题衍生详解（个人小结思考） 01背包问题是背包问题的基础类型，我们都知道对于基础问题的深入理解有助于帮助我们解答相同类型动态规划问题，相当于举一反三。所以这篇文章主要记录我对背包问题的个人理解，解释可能偏口语化。 ———— 问题描述： 在一个固定容量 V 的背包中可选择放置物体，物体总个数为 N，每个物体都有重量 Weight 与价值 Value 的属性。 如何选择放置才能找到最优解（得到的总价值最大）。 ———— 首先用贪心算法是不可行的，譬如选择 V/W 最大的优先放置，
动态规划经典--背包九讲
05-25
### 动态规划经典——背包九讲 #### 1. 01背包问题 **1.1 题目** 给定N件物品和一个容量为V的背包，每件物品都有自己的重量c[i]和价值w[i]。求解哪些物品能够放入背包内使得总价值最大。 **1.2 基本思路** 01...
C++ 算法篇 动态规划----背包之一 01背包
流年的博客
12-21 8371
一、01背包 题目：有 N 件物品和一个容量为 V 的背包。第 i 件物品的费用是 w[i]，价值是 p[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 例，有3个物品，背包容量为10，如下： 二维解法： #include<bits/stdc++.h> using namespace std; int f[50][220]={...
动态规划-背包问题小结
BUPT-WT的博客
02-28 312
1. 对于背包问题的动态转移方程: 当前容量下装满背包有几种方法: dp[j] += dp[j-nums[i]] 当前容量下能否装满或者最多能装多少: dp[j] = max(dp[j], dp[j-nums[i]]+nums[i]) 当前容量下装满的最大价值:dp[j] = max(dp[j], dp[j-weights[i]]+values[i] 当前容量下装满所用物品的最小个数:dp[j] = min(dp[j], dp[j-nums[i]]+1 2. 对于背包问题的初始化设置:
完全背包问题（动态规划）
但行好事，莫问前程
02-25 5979
完全背包问题 题目： 有 N 种物品和一个容量为 V 的背包，每种物品都有无限件可用。第 i 种物品的费用是 c[i]，价值是 w[i] 。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 一、验证动态规划求解的可行性 这个问题可以不可以像01背包问题一样使用动态规划来求解呢？来证明一下即可。 首先，先用反证法证明最优化原理： 假设完全背包...
完全背包问题-动态规划
远方水木
08-24 541
题目描述 设有N种物品，每种物品有一个重量及一个价值。但每种物品的数量是无限的，同时有一个背包，最大载重量为M，今从N种物品中选取若干件(同一种物品可以多次选取)，使其重量的和小于等于M，而价值的和为最大。 输入 第一行：两个整数，M(背包容量，M<=200)和N(物品数量，N<=30)；第2..N+1行：每行二个整数wi，vi，表示每个物品的重量和价值。 输出
完全背包问题【动态规划】
cout0
08-04 386
完全背包： 假设有 n 种物品（每种物品可装入次数不限），至多可装入容积为 m 的容器当中，试问最大可装入的价值为多少？ 设w[ i ]为第 i 件物品重量，v[ i ]为第i件物品价值 dp[ i ][ j ]表示将前 i 种物品装入重量 j 的容器当中 状态转移方程： 当i = 0 或 j = 0时，dp[ i ][ j ] = 0 当w[ i ] > j时，装不下，dp[ ...
动态规划：完全背包问题
qq_42174306的博客
04-21 5518
ACwing #3. 完全背包问题 完全背包问题和01背包问题很相似。 01背包问题每个物品只能选一个，而完全背包问题每个物品可以选无限次。 DP问题的关键是找到状态转移方程： ①定义f[i][j]表示从前 i 个物品中选择,体积为 j 的时候的最大价值。 ②那么f[i][j] = max(f[i - 1][j],f[i - 1][j - v[i]],f[i - 1][j - 2 * v[i]],.....,f[i - 1][j - k * v[i]],....) 因此代码就是： #incl
记录---完全背包问题（动态规划）
qq_37021992的博客
09-01 274
import java.util.Scanner; /** * 有一个背包，最大容量为amount，有一系列物品coins，每个物品的重量为coins[i]，每个物品的数量无限。请问有多少种方法，能够把背包恰好装满？ * 硬币问题，可以看成完全背包问题 * */ public class DP4 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int.
动态规划--完全背包问题
圣托里尼的日落啊~的博客
05-09 361
题目来源: codeup 动态规划专题 货币系统 题目描述 母牛们不但创建了他们自己的政府而且选择了建立了自己的货币系统。 [In their own rebellious way],，他们对货币的数值感到好奇。 传统地，一个货币系统是由1,5,10,20 或 25,50, 和 100的单位面值组成的。 母牛想知道有多少种不同的方法来用货币系统中的货币来构造一个确定的数值。 举例来说, 使用一个货...
《动态规划详解——背包问题九讲》PDF版
"《背包问题九讲》是ddengi创作的一份动态规划教程，主要针对NOIP级别的参赛者，详细介绍了背包问题的各种类型及其解法。这份文档旨在通过背包问题探讨动态规划的核心思想，强调读者应注重思考与实践。" 在本教程中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值