背包问题DP（01背包 完全背包 多重背包 分组背包）

---

背包问题的简介

背包问题的定义

一个可承载重量为 $W$ 的背包和 $N$ 件物品，每件物品有一个重量 $w$ 和一个价值 $v$。现在让你用这个背包装物品，要求装入的物品总重量不能超过背包可承载重量 $W$，同时使装入物品的总价值最大。

背包问题的分类

01背包问题

典型例题

题目描述：
有 $V$ 件物品和一个容量是 $V$ 的背包。每件物品只能使用一次。

第 $i$ 件物品的体积是 $v_i$，价值是 $w_i$。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式：
第一行两个整数，$N,V$，用空格隔开，分别表示物品数量和背包容积。

接下来有 $N$ 行，每行两个整数 $v_i,w_i$，用空格隔开，分别表示第 $i$ 件物品的体积和价值。

输出格式：
输出一个整数，表示最大价值。

数据范围：

$0<N,V\le 1000$
$0<v_i,w_i\le 1000$

输入样例：

4 5
1 2
2 4
3 4
4 5

输出样例：

8

实现思路

DP问题的思路模板

这里使用二维的状态表示 $f[i][j]$，用来表示 只从前 $i$ 件物品中选， 总体积 $\le j$。

这样在状态计算中， 就可以把集合划分为 $f[i-1][j]$（即只从前 $i-1$ 件物品中选且不选择第 $i$ 件物品），$f[i-1][j-v[i]]+w[i]$（$v[i]$ 表示第 $i$ 件物品的体积，$w[i]$ 表示第 $i$ 件物品的权重）（即只从前 $i-1$ 件物品中选且选了第 $i$ 件物品）。

通过以上思路可以得到状态转移方程：
$$f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i])$$

二维数组代码实现

#define _CRT_SECURE_NO_WARNINGS
#include
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 j = 0; 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;
}

一维数组优化实现

$$f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i])$$
由状态转移方程，可得 $f[i][j]$ 都是由 $[i-1]$ 更新过来的，故省略一个维度，仅保留 $[j]$ 的背包容量的维度。

即变为 $f[j]=max(f[j],f[j-v[i]]+w[i])$ ，时间复杂度不变，但空间复杂度减少。由于要满足 $if(j>=v[i])$ 条件，只需让 $j$ 从 $w[i]$ 开始遍历。

由于二维数组中状态计算都是由上一行的数据更新过来，即都是从左上方更新过来的。
如图：

由于优化为了一维数组，可看作二维数组被压缩为了一行，这个时候若是保留二维度数组的从左向右更新模式，就会导致左边数值被提前更新。

如果用二维数组来看的话其更新模式如图：

从图可知这样更新会出错误

因此要改变更新模式，改为从右边往左的更新方式，这样每回更新所用到的右边数据就都是没有更新过的数据。

代码如下：

#define _CRT_SECURE_NO_WARNINGS
#include
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 j = m; j >= v[i]; --j) // 满足if (j >= v[i])条件，同时改变遍历方向
			f[j] = max(f[j], f[j - v[i]] + w[i]);
	}
	cout << f[m] << endl;
	return 0;

扩展：记忆化搜索 + DPS 实现

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

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

int dfs(int u, int r)
{
	if (~f[u][r]) return f[u][r];
	if (u == n + 1) return 0;
	if (v[u] <= r) return f[u][r] = max(dfs(u + 1, r), dfs(u + 1, r - v[u]) + w[u]);
	return f[u][r] = dfs(u + 1, r);
}
int main()
{
	cin >> n >> m;
	memset(f, -1, sizeof f);
	for (int i = 1; i <= n; ++i) cin >> v[i] >> w[i];
	cout << dfs(1, m) << endl;
	return 0;
}

01背包之恰好装满

有 $n$ 个体积和价值分别为 $v_i,w_i$ 的物品，现从这些物品中挑选出总体积 恰好 为 $m$ 的物品，求所有方案中价值总和的最大值。

输入：包含多组测试用例，每一例的开头为两位整数 $n、m$($1\le n\le 10000,1\le m\le 1000$)，接下来有 $n$ 行，每一行有两位整数 $v_i、w_i$($1\le v_i\le 10000,1\le w_i\le 100$)。

输出：为一行，即所有方案中价值总和的最大值。若不存在刚好填满的情况，输出 −1。

测试用例：

3 4
1 2
2 5
2 1

3 4
1 2
2 5
5 1

答案：

6
-1

思路

前序状态 f[i−1][j]	前序状态 f[i−1][j−w[i]]	当前状态 f[i][j]	转移来源
有效状态(满)	有效状态(满)	有效状态(满)	$max(f[i-1][j],f[i-1][j-w[i]]+v[i])$
无效状态(不满)	有效状态(满)	有效状态(满)	$max(f[i-1][j-w[i]]+v[i],-INF)$
有效状态(满)	无效状态(不满)	有效状态(满)	$max(f[i-1][j],-INF)$
无效状态(不满)	无效状态(不满)	无效状态(不满)	$f[i][j]=max(f[i-1][j],f[i-1][j-w]+v)$，$-INF$ 会被加上 $v$，不再是 $-INF$，但肯定是负数。

恰好装满：

• 求最大值时，除了 $f[0]$ 为 $0$，其他都初始化为无穷小 -0x3f3f3f3f。

• 求最小值时，除了 $f[0]$ 为 $0$，其他都初始化为无穷大 0x3f3f3f3f。

代码实现

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

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

int main()
{
	int n, m;
	while (cin >> n >> m)
	{
		memset(f, -0x3f, sizeof f);
		for (int i = 0; i < N; ++i) f[i][0] = 0;

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

完全背包问题

典型例题

题目描述：
有 $N$ 种物品和一个容量是 $V$ 的背包，每种物品都有无限件可用。

第 $i$ 种物品的体积是 $v_i$，价值是 $w_i$。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式：
第一行两个整数，$N,V$，用空格隔开，分别表示物品种数和背包容积。

接下来有 $N$ 行，每行两个整数 $v_i,w_i$，用空格隔开，分别表示第 $i$ 种物品的体积和价值。

输出格式：
输出一个整数，表示最大价值。

数据范围：

$0<N,V\le 1000$

$0<v_i,w_i\le 1000$

输入样例：

4 5
1 2
2 4
3 4
4 5

输出样例：

10

思路分析

与01背包问题的思路大体相同， 主要在状态的计算方面有所不同，由于完全背包问题下所有可以选用的物品数量是无限的。因此状态转移方程为：$$f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i],...,f[i-1][j-k\ast v[i]]+k\ast w[i])$$

由于 $$f[i][j-v[i]]=max(f[i-1][j-v[i]],f[i-1][j-2\ast v[i]]+w[i],...,f[i-1][j-k\ast v[i]]+k\ast w[i])$$

为什么最后一项不是 $f[i-1][j-(k+1)\ast v[i]]+(k+1)\ast w[i]$ ？

• 这是因为 $k$ 的值只与背包最大容量相关

由上面两个公式我们可以推导出：

$$f[i][j]=max(f[i-1][j],f[i][j-v[i]])$$

二维数组代码实现

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

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

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

一维数组优化实现

由状态转移方程：
$$f[i][j]=max(f[i-1][j],f[i][j-v[i]])$$

类似于01背包问题的一维优化，但是由于 $f[i][j-v[i]]$ 是从数组中同行的左边数据更新而来，因此遍历方向只能从左向右，使用左边已被更新后的数据来更新右边的数据。

达到如下图的更新效果：

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

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

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

多重背包问题

多重背包问题的三种解法

注：

• n 表示物品个数
• V 表示背包的容量

① 朴素版本	② 二进制优化版本	③ 单调队列优化版本
$n\le 100,V\le 100$	$n\le 1000,V\le 2000$	$n\le 1000,V\le 20000$

朴素解法

典型题目

题目描述：
有 $N$ 种物品和一个容量是 $V$ 的背包。

第 $i$ 种物品最多有 $s_i$ 件，每件体积是 $v_i$，价值是 $w_i$。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式：
第一行两个整数，$N,V$，用空格隔开，分别表示物品种数和背包容积。

接下来有 $N$ 行，每行三个整数 $v_i,w_i,s_i$，用空格隔开，分别表示第 $i$ 种物品的体积、价值和数量。

输出格式：
输出一个整数，表示最大价值。

数据范围：
$0<N,V\le 100$
$0<v_i,w_i,s_i\le 100$

输入样例：

4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例：

10

思路

二维数组代码实现

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

const int N = 110;
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;
		for (int j = 0; j <= m; ++j)
			for (int k = 0; k <= s && k * v <= j; ++k) // 遍历第i个物品的所有选取情况
				f[i][j] = max(f[i][j], f[i - 1][j - k * v] + w * k);
	}
	cout << f[n][m] << endl;
	return 0;
}

一维数组优化实现

注意：一维化后从右向左遍历。

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

const int N = 110;
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;
		for (int j = m; j >= v; --j) // 注意从右向左遍历
		{
			for (int k = 0; k <= s && k * v <= j; ++k)
				f[j] = max(f[j], f[j - k * v] + k * w);
		}
	}
	cout << f[m] << endl;
	return 0;
}

二进制解法

典型题目

题目描述：
有 $N$ 种物品和一个容量是 $V$ 的背包。

第 $i$ 种物品最多有 $s_i$ 件，每件体积是 $v_i$，价值是 $w_i$。

求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。

输入格式：
第一行两个整数，$N,V$，用空格隔开，分别表示物品种数和背包容积。

接下来有 $N$ 行，每行三个整数 $v_i,w_i,s_i$，用空格隔开，分别表示第 $i$ 种物品的体积、价值和数量。

输出格式：
输出一个整数，表示最大价值。

数据范围：
$0<N\le 1000$
$0<V\le 2000$
$0<v_i,w_i,s_i\le 2000$

输入样例：

4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例：

10

思路

• 对于每种物品，将其数量进行二进制拆分。例如数量为13的物品，可以拆分为1,2,4,6这四个子集。
• 对每种物品的每个子集，将其看作一个新的物品，权值不变,数量变为子集的数量。
• 对这些新的物品进行01背包的动态规划。
• 在进行动态规划时，需要按照子集的数量从小到大的顺序进行遍历，以保证每个子集只被选择一次。
• 最后得到的解即为原问题的最优解。

二维数组代码实现

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

const int N = 12010, M = 2010; // log_2 2000 = 12，得到二进制分解之后的物品数量约为 12*1000
int f[N][M], v[N], w[N];

int main()
{
	int n, m, idx = 0;
	cin >> n >> m;
	for (int i = 1; i <= n; ++i)
	{
		int a, b, s;
		cin >> a >> b >> s;

		// 进行二进制分解
		int k = 1;
		while (k <= s)
		{
			idx++;
			v[idx] = a * k;
			w[idx] = b * k;
			s -= k;
			k *= 2;
		}
		if (s > 0)
		{
			idx++;
			v[idx] = a * s;
			w[idx] = b * s;
		}
	}
	n = idx; // 用二进制分解后的物品数量更新当前物品数量
	for (int i = 1; i <= n; ++i) // 经典01背包问题解决
	{
		for (int j = 0; j <= m; ++j)
		{
			f[i][j] = f[i - 1][j];
			if (v[i] <= j) f[i][j] = max(f[i][j], f[i - 1][j - v[i]] + w[i]);
		}
	}
	cout << f[n][m] << endl;
	return 0;
}

一维数组优化实现

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

const int N = 12010, M = 2010;
int f[N], w[N], v[N];

int main()
{
	int n, m, idx = 0;
	cin >> n >> m;
	for (int i = 1; i <= n; ++i)
	{
		int a, b, s, k = 1;
		cin >> a >> b >> s;
		while (k <= s)
		{
			idx++;
			v[idx] = a * k;
			w[idx] = b * k;
			s -= k;
			k *= 2;
		}
		if (s > 0)
		{
			idx++;
			v[idx] = a * s;
			w[idx] = b * s;
		}
	}
	n = idx;
	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;
}

分组背包问题

典型例题

题目描述：
有 $N$ 组物品和一个容量是 $V$ 的背包。

每组物品有若干个，同一组内的物品最多只能选一个。

每件物品的体积是 $v_{ij}$，价值是 $w_{ij}$，其中 $i$ 是组号，$j$ 是组内编号。

求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式：
第一行有两个整数 $N，V$，用空格隔开，分别表示物品组数和背包容量。

接下来有 $N$ 组数据：

每组数据第一行有一个整数 $S_i$，表示第 $i$ 个物品组的物品数量；每组数据接下来有 $S_i$ 行，每行有两个整数 $v_{ij},w_{ij}$，用空格隔开，分别表示第 $i$ 个物品组的第 $j$ 个物品的体积和价值；

输出格式：
输出一个整数，表示最大价值。

数据范围：
$0<N,V\le 100$

$0<S_i\le 100$

$0<v_{ij},w_{ij}\le 100$

输入样例：

3 5
2
1 2
2 4
1
3 4
1
4 5

输出样例：

8

思路分析

二维数组代码实现

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

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

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

一维数组优化实现

#define _CRT_SECURE_NO_WARNINGS
#include
using namespace std;

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

int main()
{
	int n, m;
	cin >> n >> m;
	for (int i = 1; i <= n; ++i)
	{
		cin >> s[i];
		for (int j = 0; 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 = 0; k < s[i]; ++k)
				// 后置的判断情况
				if (v[i][k] <= j) f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
	}
	cout << f[m] << endl;
	return 0;
}