代码随想录|动态规划|18完全背包理论基础

leetcode:52. 携带研究材料（第七期模拟笔试）

题目

有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。

完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。

同样leetcode上没有纯完全背包问题，都是需要完全背包的各种应用，需要转化成完全背包问题，所以我这里还是以纯完全背包问题进行讲解理论和原理。

在下面的讲解中，我拿下面数据举例子：

背包最大重量为4，物品为：

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

每件商品都有无限个！

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

思路

完全背包跟0-1背包的区别在于，每个物品可以无限选取。

动规五部曲

（1）dp[i][j] 表示从下标为[0~i]的物品，每个物品可以取无限次，放进容量为j的背包，价值总和最大是多少。

（2）以dp[1][4]为例：

• 放物品1

把物品1抽出来，然后总容量减去物品1的大小，剩下的容量再去放物品。

之前：剩下的容量不可以再放物品1了，dp[0][4-nums[1]]+values[1]；

现在：剩下的容量还可以再放物品1，dp[1][4-nums[1]]+values[1]；

• 不放物品1

那就放物品0，dp[0][4]。

以上过程，抽象化如下：

• 不放物品i：背包容量为j，里面不放物品i的最大价值是dp[i - 1][j]。

• 放物品i：背包空出物品i的容量后，背包容量为j - weight[i]，dp[i][j - weight[i]] 为背包容量为j - weight[i]且不放物品i的最大价值，那么dp[i][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值

递推公式： dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);

（3）初始化还是看第一列和第一行。

第一列：

如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。如图：

第一行：

状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]); 可以看出有一个方向 i 是由 i-1 推导出来，那么i为0的时候就一定要初始化。

当 j < weight[0]的时候，dp[0][j] 应该是 0

当 j >= weight[0]时，dp[0][j] 如果能放下weight[0]的话，就一直装，每一种物品有无限个。

代码是如下写的：这样子可以依次累加。 

    for (int j = weights[0]; j <= v; j++)
    {
        dp[0][j] = dp[0][j - weights[0]] + values[0];
    }

其余的点，都是通过左上方推导得到的，所以默认初始化为0即可。

（4）对于二维数组的形式，遍历物品和背包的顺序没所谓的。

先遍历物品，再遍历背包：

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

先遍历背包，再遍历物品：

for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
    for (int i = 1; i < n; i++) { // 遍历物品
        if (j < weight[i]) dp[i][j] = dp[i - 1][j];
        else dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);
    }
}

最后代码如下：

// ---------------------动态规划，完全背包问题（二维数组）---------------------
int main()
{
    // n表示物品数量，v表示背包容量
    int n, v;
    cin >> n >> v;
    
    // 存储每个物品的重量
    vector<int> weights(n);
    // 存储每个物品的价值
    vector<int> values(n);
    
    // 输入每个物品的重量和价值
    for (int i = 0; i < n; i++)
    {
        cin >> weights[i] >> values[i];
    }
    
    // 初始化动态规划数组，dp[i][j]表示前i个物品放入容量为j的背包中的最大价值
    vector<vector<int>> dp(n, vector<int>(v + 1, 0));
    
    // 初始化第一个物品在不同背包容量下的最大价值
    for (int j = weights[0]; j <= v; j++)
    {
        dp[0][j] = dp[0][j - weights[0]] + values[0];
    }
    
    // 动态规划求解，考虑每个物品放入背包的最大价值
    for (int i = 1; i < n; i++)
    {
        for (int j = 0; j <= v; j++)
        {
            // 如果当前背包容量小于当前物品重量，则不放入该物品
            if (j < weights[i])
                dp[i][j] = dp[i - 1][j];
            else
                // 否则，选择放入或不放入当前物品的最大价值
                dp[i][j] = max(dp[i - 1][j], dp[i][j - weights[i]] + values[i]);
        }
    }
    
    // 输出最大价值
    cout << dp[n - 1][v];
}

---

一维数组解法

递推公式变为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

在0-1背包里面：

二维数组，物品和背包的遍历顺序无所谓；

一维数组，先遍历物品，再遍历背包。

在完全背包里面：

二维数组，遍历顺序无所谓；

一维数组，遍历顺序也无所谓。

因为dp[j] 是根据 下标j之前所对应的dp[j]计算出来的。 只要保证下标j之前的dp[j]都是经过计算的就可以了。

还有一个重要的点就是，第二个for循环（假设是遍历背包）不需要再从后往前遍历了，因为这里可以重复，所以从前往后遍历就行。

这里跟0-1背包的一维数组解法区别开来。

// ---------------------动态规划，完全背包问题（一维数组）---------------------
int main()
{
    // n表示物品数量，v表示背包容量
    int n, v;
    cin >> n >> v;

    // 存储物品的重量
    vector<int> weights(n);
    // 存储物品的价值
    vector<int> values(n);

    // 读取每个物品的重量和价值
    for (int i = 0; i < n; i++)
    {
        cin >> weights[i] >> values[i];
    }

    // 初始化动态规划数组，dp[j]表示背包容量为j时的最大价值
    vector<int> dp(v + 1, 0);

    // 遍历每个物品，从0到n-1
    for (int i = 0; i < n; i++)
    {
        // 遍历背包容量，从0到v
        for (int j = 0; j <= v; j++)
        {
            // 如果当前背包容量可以放入第i个物品
            if (j >= weights[i])
                // 更新dp[j]，选择放入或不放入第i个物品的最大价值
                dp[j] = max(dp[j], dp[j - weights[i]] + values[i]);
        }
    }

    // 输出背包容量为v时的最大价值
    cout << dp[v];
}

总结

本文的纯完全背包问题，无论是二维还是一维，遍历的顺序没有要求。

但是后面的题，涉及到“装满背包有多少种方式”，对顺序就有要求了，具体还要考虑是组合问题还是排列问题。

参考资料

代码随想录