01背包问题

原创已于 2024-01-30 15:10:15 修改 · 913 阅读

23 ·

CC 4.0 BY-SA版权

文章标签：

#算法

于 2024-01-29 16:25:24 首次发布

algorithms 专栏收录该内容

30 篇文章

订阅专栏

本文介绍了如何使用记忆化搜索和动态规划解决物品选择问题，通过比较暴力搜索，详细解释了记忆化搜索的思想并给出了递归式和动态规划的实现方法。

题目描述

有 $n$ 个重量和价值分别为 $w_i$ ， $v_i$ 的物品。从这些物品中挑选出总重量不超过 $W$ 的物品，求所有挑选方案中价值总和的最大值。
数据范围：
$1\le n\le100$
$1\le w_i,v_i\le100$
$1\le W\le10000$

记忆化搜索

暴力搜索

递归方程：令 $df s (i, j) =$ 从编号为 $i$ 的物品开始挑选出总重量不超过 $j$ 的物品，所有挑选方案中价值总和的最大值。（编号从 0 开始，最后一个物品编号为 $n - 1$ ）

核心思想：对于编号为 $i$ 的物品，可以选择 不拿 或者 拿
不拿：相当于从下一个物品（编号为 $i + 1$ ）开始挑选总重量仍然不超过 $j$ 的物品，即 $df s (i + 1, j)$ 。
拿：由于拿了重量为 $w_i$ 的物品，则总重量由 $j$ 变成了 $j-w_i$ 。相当于从下一个物品（编号为 $i + 1$ ）开始挑选总重量不超过 $j-w_i$ 的物品，即 $dfs(i+1,j-w_i)$ 。
方程：
$\begin{split} dfs(n,j)&=0 \\ dfs(i,j)&=\begin{cases} dfs(i+1,j)&,j<w_i \\ max\{dfs(i+1,j),dfs(i+1,j-w_i)+v_i\}&,j\ge w_i \end{cases} \end{split}$
代码

// 输入
int n, W;                // n -- 物品个数；W -- 最大重量
int w[WMAX], v[VMAX];    // w[WMAX] -- 物品重量；v[VMAX] -- 物品价值

// dfs(i, j) -- 从编号为i开始挑选总重不超过j的物品，返回最大价值
int dfs(int i, int j)
{
	if (i == n)
		return 0;
	
	int ret;
	if (j < w[i])
		ret = dfs(i + 1, j);
	else
		ret = max(dfs(i + 1, j), dfs(i + 1, j - w[i]) + v[i]);
		
	return ret;
}

// 输出
void solve(void)
{
	printf("%d\n", dfs(0, W));
}

记忆化

我们用一组数据来看一下暴力搜索的过程。

n = 4, W = 5
(w, v) = {(2, 3), (1, 2), (3, 4), (2, 2)}

我们用二叉树的形式来描述该过程：
暴力搜索过程
我们发现 $df s (3, 2)$ 执行了两次，这显然造成了浪费。如果能把第一次的结果记录下来，那么就避免了第二次的计算。这就是记忆化搜索，把搜索过程中的结果记录下来，避免重复的搜索。

// 输入
int n, W;                    // n -- 物品个数；W -- 最大重量
int w[WMAX], v[VMAX];        // w[WMAX] -- 物品重量；v[VMAX] -- 物品价值
int dp[MAX][MAX];            // 记忆化数组，必须足够大

// dfs(i, j) -- 从编号为i开始挑选总重不超过j的物品，返回最大价值
int dfs(int i, int j)
{
	if (i == n)
		return 0;
	
	// 使用已经计算过的结果
	if (dp[i][j] >= 0)
		return dp[i][j];
	
	int ret;
	if (j < w[i])
		ret = dfs(i + 1, j);
	else
		ret = max(dfs(i + 1, j), dfs(i + 1, j - w[i]) + v[i]);
		
	return ret;
}

// 输出
void solve(void)
{
	memset(dp, -1, sizeof(dp));    // 初始化记忆数组
	
	printf("%d\n", dfs(0, W));
}

不难看出，与暴力搜索相比，记忆化搜索在原来的基础上，只不过多了 记忆化数组的声明和初始化 和 访问记忆化数组。
值得注意的是，记忆化数组必须开得足够大。因为它是用来记录 $df s (i, j)$ 的结果的，所以必须使 $d p [i] [j]$ 总是合法，不会越界访问。

动态规划

对于动态规划来说，最重要的就是 递推关系式。一般，我们可以先写出搜索算法，再得到递推式；我们也可以直接得出递推式。

由搜索递归函数得到递归式

由上文 暴力搜索 提到的函数递归式，我们可以写出动态规划的递推式。
$\begin{split} dp[n][j]&=0 \\ dp[i][j]&=\begin{cases} dp[i+1][j]&,j<w_i \\ max\{dp[i+1][j],dp[i+1][j-w_i]+v_i\}&,j\ge w_i \end{cases} \end{split}$
有了递推式，我们就可以通过循环来计算。

// 输入
int n, W;                    // n -- 物品个数；W -- 最大重量
int w[WMAX], v[VMAX];        // w[WMAX] -- 物品重量；v[VMAX] -- 物品价值
int dp[MAX][MAX]             // dp数组，与记忆化数组一样，必须足够大

void solve(void)
{
	for (int i = n - 1; i >= 0; i--)
	{
		for (int j = 0; j <= W; j++)
		{
			if (j < w[i])
				dp[i][j] = dp[i + 1][j];
			else
				dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - w[i]] + v[i]);
		}
	}

	printf("%d\n", dp[0][W]);
}

直接写出递归式

定义 $d p [i] [j] =$ 从前 $i$ 个中选出总重量不超过 $j$ 的物品。（因为编号从 $0$ 开始，所以前 $i + 1$ 个物品，最后一个物品的编号为 $i$ ）
$\begin{split} dp[0][j]&=0 \\ dp[i + 1][j]&=\begin{cases} dp[i][j]&,j<w_i \\ max\{dp[i][j],dp[i][j-w_i]+v_i\}&,j\ge w_i \end{cases} \end{split}$

// 输入
int n, W;                    // n -- 物品个数；W -- 最大重量
int w[WMAX], v[VMAX];        // w[WMAX] -- 物品重量；v[VMAX] -- 物品价值
int dp[MAX][MAX]             // dp数组，与记忆化数组一样，必须足够大

void solve(void)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j <= W; j++)
		{
			if (j < w[i])
				dp[i + 1][j] = dp[i][j];
			else
				dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
		}
	}

	printf("%d\n", dp[n][W]);
}