代码随想录|动态规划|12“0-1”背包问题二-优快云博客

本文链接：https://blog.youkuaiyun.com/ZJFJhanxi/article/details/146919022

题目

背包最大重量为4。

物品为：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

问背包能背的物品最大价值是多少？

思路

二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

如果把上一层i-1的内容赋给i，那么表达式变为：

dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);

那么这里的i就没有意义了，可以只用一维数组就实现：

dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

下面来逐步分析

动规五部曲

（1）在一维dp数组中，dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。

（2）跟上面分析的一样，只考虑j，递推公式如下：

dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

（3）dp[0]=0没问题，然后每次递推求的是max，所以保证初始值是小值，也就全部默认为0即可

（4）递推公式主要是对j进行递推，所以j的循环在i的循环里面，也就是先遍历物品，再遍历背包。

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

    }
}

这里遍历背包用的是倒序，为什么？

倒序遍历是为了保证物品i只被放入一次！

举一个例子：物品0的重量weight[0] = 1，价值value[0] = 15

如果正序遍历（这里都是i=0的情况下）

dp[1] = dp[1 - weight[0]] + value[0] = 15

dp[2] = dp[2 - weight[0]] + value[0] = 30

此时dp[2]就已经是30了，意味着物品0，被放入了两次，所以不能正序遍历。

为什么倒序遍历，就可以保证物品只放入一次呢？

倒序就是先算dp[2]

dp[2] = dp[2 - weight[0]] + value[0] = 15 （dp数组已经都初始化为0）

dp[1] = dp[1 - weight[0]] + value[0] = 15

为什么二维dp数组遍历的时候不用倒序呢？

dp[i][j]都是通过上一层即dp[i - 1][j]计算而来，本层的dp[i][j]并不会被覆盖。

（5）一位dp举个例子如下：

代码如下：

int main()
{
    // M个物品，最大空间N
    int M, N;
    // 输入物品数量和最大空间
    cin >> M >> N;
    // 初始化物品重量和价值的向量
    vector<int> weights(M);
    vector<int> values(M);
    // 输入每个物品的重量
    for (int i = 0; i < weights.size(); i++)
    {
        cin >> weights[i];
    }
    // 输入每个物品的价值
    for (int j = 0; j < values.size(); j++)
    {
        cin >> values[j];
    }

    // 初始化动态规划数组，dp[j]表示容量为j时的最大价值
    vector<int> dp(N + 1, 0);
    // 遍历每个物品
    for (int i = 0; i < weights.size(); i++)
    {
        // 从后向前更新dp数组，确保每个物品只被考虑一次
        for (int j = N; j >= weights[i]; j--)
        {
            // 更新dp[j]，选择当前物品或不选择当前物品的最大价值
            dp[j] = max(dp[j], dp[j - weights[i]] + values[i]);
        }
    }
    // 输出最大价值
    cout << dp[N];
}