完全背包的一维和二维dp数组

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

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

01背包和完全背包唯一不同就是体现在遍历顺序上。

首先回顾0-1背包的核心代码：

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.size-1的闭区间，理解为物品0到物品weight.size()-1。

还可以写成：

for (int i = 1; i <= weight.size(); i++) {
    for (int j = bagWeight; j >= weight[i-1]; j--) {
        dp[j] = max(dp[j], dp[j-weight[i-1]] + value[i-1]);
    }
}

i的范围为1到weight.size()闭区间，理解为前1件物品和前weight.size()件物品。

两者大同小异，唯一区分于写法，dp[j]的推导公式中,第i件物品的weight写法不同。

0-1背包内嵌的循环是从大到小遍历，为了保证每个物品仅被添加一次。

而完全背包的物品是可以添加多次的，因此要从小到大遍历，即：

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

    }
}

或者：

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

    }
}

需要考虑一个问题：为什么遍历物品在外层循环，遍历背包容量在内层循环？

在完全背包中，对于一维dp数组来说，其实两个for循环嵌套顺序无所谓！

因为dp[j]是根据下标j之前所对应的dp[j]计算出来的，只要保证下标j之前的dp[j]都是经过计算的就可以了（容量的遍历是从小到大遍历，也就是从小到大计算）。

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

或者：

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

最后，又可以出一道面试题了，就是纯完全背包，要求先用二维dp数组实现，然后再用一维dp数组实现，最后在问，两个for循环的先后是否可以颠倒？为什么？

二维dp数组实现：

和0-1背包二维dp数组的代码只有一个下标不同！

两个for循环的遍历顺序是可以颠倒的，这跟递归的本质和递推的方向有关系。dp[i][j] = max(dp[i - 1][j], dp[i][j - weight[i-1]] + value[i-1])；递归公式中可以看出dp[i][j]是靠dp[i-1][j]和dp[i][j - weight[i-1]]推导出来的，他们俩都在dp[i][j]的左上角方向（包括正左和正上两个方向），分析先遍历物品和先遍历背包的过程，在计算dp[i][j]之前都已经得到了，不影响公式的推导！

// 0-1背包问题
// 二维dp数组
// n个物品 背包容量为m
int knapSack(int n, int m, vector<int>& weight, vector<int>& value) {
    vector<vector<int> dp(n+1, vector<int>(m+1, 0));
    // dp[i][j]:从前i个物品中选择放入容量为j的背包中得到的最大价值
    // 注意这种定义，第i件物品的重量为weight[i-1],价值为value[i-1]
    // dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i-1]] + value[i-1])
    // 初始化
    // 当j=0时，背包容量为0，最大价值为0；当i=0时，也就是前0件物品，也就是没有物品，最大价值也是0
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (j - weight[i-1] < 0) // 如果当前背包容量放不下第i件物品，那么前i件物品放入背包得到的最大价值就是前i-1件物品放入获得的最大价值
                dp[i][j] = dp[i-1][j];
            else { // 如果能放下，从放和不放两种选择里取最大值，这里要注意，其实完全背包二维数组的代码跟一维只有下面一个下标不同，那就是“放i”这个选择，因为是可以重复放的，所以是dp[i]
                dp[i][j] = max(dp[i-1][j], dp[i][j-weight[i-1]] + value[i-1]);
            }
        }
    }
    return dp[n][m];
}

一维dp数组实现：

和0-1背包的一维数组实现代码的唯一不同在于：0-1背包容量遍历是从大到小的，防止数据重复使用。

for循环遍历顺序是可以颠倒的，因为dp[j]是根据下标j之前所对应的dp[j]计算出来的，只要保证下标j之前的dp[j]都是经过计算的就可以了（容量的遍历是从小到大遍历，也就是从小到大计算）。

// 完全背包问题
// 一维dp数组
// n个物品 背包容量为m
int knapSack(int n, int m, vector<int>& weight, vector<int>& value) {
    vector<int> dp(m+1, 0);
    // 当j=0时，背包容量为0，最大价值为0
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (j - weight[i-1] >= 0)
                dp[j] = max(dp[j], dp[j-weight[i-1]] + value[i-1]);
        }
    }
    return dp[m];
}