背包9讲系列1-01背包问题

天逸coder

已于 2024-10-01 19:23:04 修改

阅读量506

点赞数 9

分类专栏： # 背包9讲文章标签：算法动态规划 java

于 2023-11-28 01:53:22 首次发布

本文链接：https://blog.csdn.net/luhu124541/article/details/134657981

版权

背包9讲专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、前言

最近打算出一个背包问题的专栏，详细介绍一下常见的几种不同类型的背包问题及其解题思路和方法，欢迎各位留言探讨。

二、什么是背包问题？

背包问题是动态规划中的一个分支，其目标是在给定的一组物品中选择一些物品放入背包，使得在满足背包容量限制的情况下，所选物品的总价值最大化或总重量最小化。背包问题大致可以分为9类，本章讲解的是01背包问题。

三、01背包

3.1 问题描述

有n个物品和一个容量为capacity的背包，每种物品只有一件，他们的体积分别为weights[i](0<=i<n)，价值分别为values[i](0<=i<n)，求将哪些物品装入背包可使价值总和最大？

3.2 解体思路

3.2.1 确定状态变量（函数）

最大价值是物品数量i与背包容量j的函数，设dp[i][j]表示从前i件物品中进行选择，放入容量为j的背包所能获得的最大价值

3.2.2 确定状态转移方程（递推关系）

对于第i个物品(第1个物品体积为weights[0]，第i个物品体积为weights[i-1])的选择情况如下：

如果当前背包剩余容量j<weights[i-1]，则无法将该物品装入背包，此时最大价值与从前i-1个物品选择，放入容量为j的背包所能获得的最大价值相同
```
dp[i][j] = dp[i-1][j]
```
如果当前背包剩余容量j>=weights[i-1]，则能放入第i件物品，但是需要判断放入该物品与不放入时哪种情况所能取到的价值最大。

2.1 如果第i件物品不放入背包
```
dp[i][j] = dp[i-1][j]
```
2.2.如果第i件物品放入背包，背包剩余容量为j-weights[i-1]，要使总价值最大，相当于从前i-1个物品中进行选择，放入容量为j-weights[i-1]的背包的最大价值再加上第i件物品的价值values[i-1]
```
dp[i][j] = dp[i-1][j-weights[i-1]] + values[i-1]
```
2.3.所以当j>=weights[i-1]时，我们只需要选择两种情况下的最大值即可
```
dp[i][j] = max(dp[i-1][j], dp[i-1][j-weights[i-1]] + values[i-1])
```

综上所述，状态转移方程如下：

1.j<weights[i-1]: 
	dp[i][j] = dp[i-1][j]
2.j>=weights[i-1]
	dp[i][j] = max(dp[i-1][j], dp[i-1][j-weights[i-1]] + values[i-1])

3.2.3 确定边界条件

当背包容量为0时，无法放入任何物品到背包中，总价值为0，即dp[i][0]=0 (0<=i<=n，n为物品总数量)
当不放入任何物品到背包中时，总价值也为0，即dp[0][j]=0(0<=j<=capacity，capacity为背包最大容量)

3.2.4 代码示例

/**
 * 背包问题-背包9讲
 */
public class KnapsackQuestion {
    /**
     * 01背包
     *
     * @param weights  存储n件物品重量的数组，weights[i-1]表示第i件物品的重量(下标从0开始)
     * @param values   存储n件物品价值的数组，values[i-1]表示第i件物品的价值
     * @param capacity 背包的容量
     * @return 从n件物品中进行选择，放入容量为capacity的背包中所能取得的最大价值
     */
    public int knapsack01(int[] weights, int[] values, int capacity) {
        // dp[i][j]表示从前i件物品中选择，放入容量为j的背包的最大价值
        int n = weights.length;
        int[][] dp = new int[n + 1][capacity + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= capacity; j++) {
                if (j >= weights[i - 1]) {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weights[i - 1]] + values[i - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        return dp[n][capacity];
    }
}

3.2.5 空间优化-滚动数组

从上面的代码中不难发现，外层循环遍历到第i次时，只用到了第i-1次遍历后容量小于等于j的dp元素值，所以可以通过将二维数组降维为一维数组对空间进行优化，设dp[j]为从前i个物品中进行选择，放入容量为j的背包所能获得的最大价值，dp[i][j]可以看作是外层第i次循环所获得的dp[j],dp[i-1][j]可看作是外层第i-1(即上一次)循环所获得的dp[j]，状态转移关系如下：

1.j<weights[i-1]: 
	第i次循环得到的dp[j] = 上一次循环得到的dp[j]
2.j>=weights[i-1]
	第i次循环得到的dp[j] = max(上一次循环得到的dp[j], 上一次循环得到的dp[j-weights[i-1]] + values[i-1])

如何保留上一次循环时的dp值？以dp[j]=dp[j-weights[i-1]]为例，如果顺序遍历dp数组并更新当前值，那么在遍历到dp[j]之前就已经更新了dp[j-weights[i-1]]了，也就是说第i次循环得到的dp[j]实际上是由第i次循环得到的dp[j-weights[i-1]]转移得到而不是上一次循环得到的dp[j-weights[i-1]]转移而来，故不能顺序更新dp数组，而应该逆序更新dp数组。
仍以dp[j]=dp[j-weights[i-1]]为例，如果逆序更新，则遍历到dp[j]时dp[j-weights[i-1]]是没有被本次的内层循环更新的，dp[j-weights[i-1]]所保留的还是外层的上一次循环得到的值，满足要求

for j=capacity; j >= weights[i-1]; j--
	dp[j] = dp[j-weights[i-1]]

代码示例如下：

/**
 * 背包问题-背包9讲
 */
public class KnapsackQuestion {
    /**
     * 01背包-滚动数组
     * 时间复杂度：O(MN) M表示背包的容量，N表示物品的数量
     * 空间复杂度：O(M) M表示背包的容量
     *
     * @param weights  存储n件物品重量的数组，weights[i-1]表示第i件物品的重量(下标从0开始)
     * @param values   存储n件物品价值的数组，values[i-1]表示第i件物品的价值
     * @param capacity 背包的容量
     * @return 从n件物品中进行选择，放入容量为capacity的背包中所能取得的最大价值
     */
    public int knapsack01WithRollingArray(int[] weights, int[] values, int capacity) {
        int n = weights.length;
        int[] dp = new int[capacity + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = capacity; j >= weights[i - 1]; j--) {
                dp[j] = Math.max(dp[j], dp[j - weights[i - 1]] + values[i - 1]);
            }
        }
        return dp[capacity];
    }
}