01 背包

物品编号	1	2	3	4
物品体积	2	3	4	5
物品价值	3	4	5	6

方法：

1.确定dp数组

背包容量是从0到8。

物品编号的意思是：

如果物品编号是0的话，我们不拿物品，

编号是1的话，我们可以选择编号为1的物品，

编号是2的话，我们可以选择编号为1,2的物品，

所以，编号为 i 的时候，我们可以选择编号为1到 i 的物品。

所以dp[i][j]表示在前i个物品中，背包容量为j的情况下，背包中能装下的最大价值。

2.确定递推公式

首先，一个物品可以是拿与不拿。也就是判断现在这个容量的背包能不能装下这个物品：

在背包容量为0与物品编号为0时（也就是一件也不拿），这种情况背包中能装下的价值为0：

然后看第二列：

当我们判断到dp[1][1]时，我们就要判断能不能装下当前物品编号对应的物品，也就是物品1。背包容量是1，物品1的体积是2，所以装不下。因为装不下，所以现在背包的最大价值等于当前列的上一行的价值，也就是dp[0][1]，也就是0。这一列都是这样的情况。

所以，当装不下物品 i 时：

dp[i][j]=dp[i-1][j];

再看第三列：

背包的容量是2，我们判断dp[1][2]。物品1的体积是2，可以装下。

如果不装的话，

dp[i][j]=dp[i-1][j];

这样dp[1][2]=0。

如果装物品的话，那么我们的想法是，我们把物品装到背包中之后，背包剩余的空间所能装的最大价值的加上当前物品的价值就是当前的最大价值，即：

dp[i][j]=dp[i-1][j-volume[i]] + value[i];

解释一下这个表达式的含义：

dp[ i ][ j ]表示当前的最大价值，i 表示可以选择编号为1到 i 的物品，j 表示当前背包的容量为 j 。

在dp[ i - 1 ][ j - volume[ i ] ]中，因为我们选择装编号为 i 的物品，所以我们要计算编号为1到 i - 1 的物品中，我们剩余背包容量 j - volume[ i ] 能装的最大的价值。

volume[ i ]表示我们选择的编号为 i 的物品的体积。

最后要加上我们选择的物品i的价值value[ i ]。

这样计算得dp[1][2]=3

递推公式应该为上述两个公式的较大者，即：

max(dp[i-1][j],dp[i-1][j-volume[i]] + value[i]);

按照这个方法我们填第三列：

dp[1][2]: 可以装下物品编号为1的物品，那么

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

dp[2][2]:装不下编号为2的物品，那么

dp[i][j]=dp[i-1][j];

dp[3][2]:装不下编号为2的物品，那么

dp[i][j]=dp[i-1][j];

dp[4][2]:装不下编号为2的物品，那么

dp[i][j]=dp[i-1][j];

 总结：

如果装不下体积为i的物品，那么：

dp[i][j]=dp[i-1][j];

如果能装下体积为i的物品，那么

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

按这个方法我们填完整个表：

举例：比如dp[4][8]

当前背包容量是8，编号为4的物品体积是5，能装下，所以我们去寻找 dp[ i - 1 ][ j - volume[ i ]]

dp[ i - 1 ][ j - volume[ i ]]=dp[3][4]

dp[3][4]已经是我们之前求出的最大的价值，是5

然后加上编号为4的物品的价值，得出10

最后与dp[i-1][j]的价值比较一下，dp[i-1][j]的价值是9，小于10，

所以dp[4][8]=10

3.确定dp数组如何初始化

因为递推公式需要依靠之前求出的数据来得出答案，所以我们需要初始化。

首先，在背包容量为0与物品编号为0时肯定都初始化为0：

只是这样初始化肯定是不行的，

我们还需要初始化第二列和第二行：

4.确定遍历顺序（从前往后，从后往前）

遍历肯定是两个嵌套的for循环，有两种循环方式：

先行后列，先列后行，也就是先背包后物品还是先物品后背包的区别。

这两种方法都可以。

5.若出错，输出dp数组

如果输出与预期不符的话，我们检查错误的方法就是输出dp数组，看看是否与我们手动算出的dp数组一样。

代码明天在写>_< 

2022.11.6

（的确是第二天写的 0^0）

在dp数组初始化方面，一开始把数组全部初始化为0：

vector<int> valume = { 2,3,4,5 };
vector<int> value = { 3,4,5,6 };
int bagValume = 8;
 
vectorint>> dp(valume.size() + 1, vector<int>(bagValume + 1));

valume数组是物品体积，value数组是物品价值，bagValume是背包的容量

我们要初始化的dp数组是5行9列的数组

解释一下咋初始化的：

格式：

vectorint>> dp(行数, vector<int>(列数,要初始化的数默认是0));

vectorint>> dp(valume.size() + 1, vector<int>(bagValume + 1));

输出看一下对不对：

for (int i = 0; i < dp.size(); i++) {
        for (int j = 0; j < dp[i].size(); j++) {
            printf("%3d", dp[i][j]);
        }
        printf("\n");
    }

然后是初始化i为1那行：

    for (int i = valume[0]; i <= bagValume; i++) {
        dp[1][i] = value[0];
    }

最后是按照   2.确定递推公式  中总结的写出递推公式：

for (int i = 2; i <= valume.size(); i++) {
        for (int j = valume[0]; j <= bagValume; j++) {
            if (valume[i - 1] > j) {
                dp[i][j] = dp[i - 1][j];
            }
            else {
                dp[i][j] = max(dp[i - 1][j - valume[i - 1]]+value[i-1], dp[i - 1][j]);
            }
        }
    }

最终代码：

#include
#include
 
using namespace std;
 
void BagMaxValue() {
    vector<int> valume = { 2,3,4,5 };
    vector<int> value = { 3,4,5,6 };
    int bagValume = 8;
 
    vectorint>> dp(valume.size() + 1, vector<int>(bagValume + 1));
    
 
    for (int i = valume[0]; i <= bagValume; i++) {
        dp[1][i] = value[0];
    }
 
 
    for (int i = 2; i <= valume.size(); i++) {
        for (int j = valume[0]; j <= bagValume; j++) {
            if (valume[i - 1] > j) {
                dp[i][j] = dp[i - 1][j];
            }
            else {
                dp[i][j] = max(dp[i - 1][j - valume[i - 1]]+value[i-1], dp[i - 1][j]);
            }
        }
    }
 
    printf("dp数组:\n");
    for (int i = 0; i < dp.size(); i++) {
        for (int j = 0; j < dp[i].size(); j++) {
            printf("%3d", dp[i][j]);
        }
        printf("\n");
    }
 
    printf("最大价值:\n");
    cout << dp[valume.size()][bagValume] << endl;
 
 
}
 
 
int main()
{
    BagMaxValue();
 
    return 0;
}

输出结果：