9. 分组背包问题(acwing)

9. 分组背包问题

题目描述

有 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≤100

0<S_i≤100

0<v_ij,w_ij≤100

输入样例

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

输出样例：

8

动态规划

二维数组

这段代码是分组背包问题的解决方案。详细注释如下：

#include<bits/stdc++.h>
using namespace std;

// v和w数组按照组编号和组内编号存储每个物品的体积和价值
// s数组存储每个组的物品个数
int v[110][110], w[110][110], s[110];
// dp数组用于动态规划，dp[i][j]表示前i组物品放入容量为j的背包可以得到的最大价值
int dp[110][110];

int main()
{
    int n,m; // n为物品组数，m为背包容量
    cin>>n>>m;
    // 读取每组物品的信息
    for(int i=1; i<=n; i++)
    {
        cin>>s[i]; // 读取第i组的物品数量
        for(int j=0; j<s[i]; j++)
            cin>>w[i][j]>>v[i][j]; // 读取第i组中每个物品的体积和价值
    }
    // 动态规划处理每组物品
    for(int i=1; i<=n; i++) // 遍历每组物品
    {
        // 遍历所有可能的背包容量
        for(int j=0; j<=m; j++)
        {
            // 先继承上一组物品决策的价值
            dp[i][j]=dp[i-1][j];
            // 在当前背包容量下尝试放入这一组内的每个物品
            for(int k=0; k<s[i]; k++)
            {
                // 如果当前背包容量可以放下这个物品
                if(j>=w[i][k])
                    // 更新当前的最大价值
                    // dp[i-1][j-w[i][k]] 表示在放入这个物品之前的背包的最大价值
                    // v[i][k] 表示当前物品的价值
                    // 选择这两种方案中价值更大的一个作为dp[i][j]的值
                    dp[i][j]=max(dp[i][j], dp[i-1][j-w[i][k]] + v[i][k]);
        }
    }
    // 输出所有组物品决策完毕后，容量为m的背包能够达到的最大价值
    cout<<dp[n][m];
}

分组背包问题与01背包问题不同之处在于，每组物品中只能选择一个物品。此代码通过二维的 dp 数组来记录状态，其中 dp[i][j] 表示考虑到第 i 组物品，当前背包容量为 j 时的最大价值。对于每组物品，内层循环遍历组内所有物品，并判断在当前背包容量下是否能放入该物品，若能放入，则尝试更新当前组在该背包容量下的最大价值。这种方法保证了同一组内的物品最多只有一个被选中。最后输出 dp[n][m] 即为所有组物品决策完毕后，背包容量为 m 的背包所能达到的最大价值。

一维数组

这段代码是一个分组背包问题的解决方案，使用了动态规划的方法。下面是详细的代码注释：

#include<bits/stdc++.h>
using namespace std;

// v和w二维数组存储每个组中每个物品的体积和价值
int v[110][110], w[110][110];
// s数组存储每个组的物品数
int s[110];
// dp数组用于动态规划，dp[j]表示当前背包容量为j时的最大价值
int dp[110];

int main()
{
    int n, m; // n表示物品组数，m表示背包的最大容量
    cin >> n >> m;
    
    // 输入每组物品的数据
    for(int i = 1; i <= n; i++)
    {
        cin >> s[i]; // 输入第i组的物品数量
        for(int j = 0; j < s[i]; j++)
            cin >> w[i][j] >> v[i][j]; // 输入第i组中每个物品的体积和价值
    }
    
    // 遍历每一组物品
    for(int i = 1; i <= n; i++)
    {
        // 逆序遍历背包容量，这是为了确保每组物品只被选取一次
        for(int j = m; j >= 0; j--)
        {
            // 遍历第i组的所有物品
            for(int k = 0; k < s[i]; k++)
            {
                // 如果当前背包容量可以容纳第i组的第k个物品
                if(j >= w[i][k])
                    // 更新dp[j]，决策是不取该物品时的价值，或者是取该物品
                    // 加上剩余容量dp[j - w[i][k]]时的价值，两者取较大值
                    dp[j] = max(dp[j], dp[j - w[i][k]] + v[i][k]);
            }
        }
    }
    
    // 输出背包容量为m时能够达到的最大价值
    cout << dp[m];
}

代码逻辑如下：

1. 定义了几个数组，v 和 w 分别存储每组中每个物品的体积和价值，s 存储每组的物品数量，dp 用于动态规划，存储达到当前背包容量时的最大价值。

2. main 函数从标准输入中读取物品组数和背包容量，并接着读取每组物品的数量以及每个物品的体积和价值。

3. 对于每个物品组，进行动态规划。为了保证每组物品中只取一个，内层循环对背包容量从大到小进行遍历，这样可以确保在更新 dp[j] 时，依赖的是未更新的状态，从而确保每组物品只被考虑一次。

4. 对于每个物品，检查当前背包容量是否足以放下该物品。如果可以，就尝试更新当前容量下的最大价值。

5. 在动态规划结束后，输出 dp[m]，即背包容量为 m 时的最大价值，这就是所求的答案。