背包问题（01、完全背包、多重背包）

一篇文章吃透背包问题

01背包问题

每个物品只有一件，拿或不拿。
使⽤⼆维数组，即dp[i][j] 表示从下标为[0-i]的物品⾥任意取，放进容量为j的背包，价值总和最⼤是多少。
怎么推导出dp[i][j]呢？

• 由dp[i - 1][j]推出，即背包容量为j，⾥⾯不放物品i的最⼤价值，此时dp[i][j]就是dp[i - 1][j]
• 由dp[i - 1][j - weight[i]]推出， dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最⼤价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最⼤价值
• 所以递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

public class ZeroOneBag {
    public static void main(String[] args) {
        int n = 3;
        int S = 4;
        int[] weights = new int[]{1,3,4};
        int[] values = new int[]{15,20,30};
        System.out.println(new ZeroOneBag().zeroOne(n, S, weights, values));
    }

    public int zeroOne(int n, int S, int[] weights, int[] values){
        int[][] dp = new int[n+1][S+1];
        for(int i = 1; i <= n; i++){
            int w = weights[i-1];
            int v = values[i-1];
            for(int j = 1; j <= S; j++){
                if(j >= w)
                    dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-w] + v);
                else
                    dp[i][j] = dp[i-1][j];
            }
        }
        return dp[n][S];
    }
}

dp[i][j] 只与 dp[i-1][j] 和 dp[i-1][j-w]有关，也就是当前行的某个值只与前一行的两个值有关。可以只用一维数组记录，空间优化后的状态转移方程：

dp[j] = max{ dp[j], dp[j-w] + v }

//N为物品数目
//S为背包容量
//weights[]为每个物品的体积
//values[]为每个物品的价值
public int zeroOne2(int n, int S, int[] weights, int[] values){
    int[] dp = new int[S+1];
    for(int i = 1; i <= n; i++){
        int w = weights[i-1];
        int v = values[i-1];
        for(int j = S; j >= w; j--){//注意从后向前遍历，避免重复
            dp[j] = Math.max(dp[j], dp[j-w] + v);
        }
    }
    return dp[S];
}

相关题

1. 416.分割等和⼦集
2. 1049.最后⼀块⽯头的重量 II
3. 494. ⽬标和
4. 474. 一和零

完全背包问题

有N件物品和⼀个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。 每件物品都有⽆限个（也就是可以放⼊背包多次） ，求解将哪些物品装⼊背包⾥物品价值总和最⼤。
这个问题只给一个一维动态的DP做法，跟01背包的一维写法恰恰相反。

顺便说一下我思考的一个问题：01背包用二维DP的时候，两层循环实际上都是从前往后遍历的，但是一维DP中的第二层循环（容量循环）必须从后往前，否则会出现重复使用某个元素的问题。
但是完全背包情况下，恰恰利用了这一点。
完全背包的二维写法不太好写，我也不会。

//N为物品数目
//S为背包容量
//weights[]为每个物品的体积
//values[]为每个物品的价值
public class FullBag {
    public static void main(String[] args) {
        int n = 3;
        int S = 4;
        int[] weights = new int[]{3,3,1};
        int[] values = new int[]{15,20,30};
        System.out.println(new FullBag().full2(n, S, weights, values));
    }

    public int full2(int n, int S, int[] weights, int[] values){
        int[] dp = new int[S+1];
        for(int i = 1; i <= n; i++){
            int w = weights[i-1];
            int v = values[i-1];
            for(int j = w; j <= S; j++){
                dp[j] = Math.max(dp[j], dp[j-w] + v);
            }
        }
        return dp[S];
    }
}

多重背包

每个物品除了重量weights[i]、价值values[i]，还有个数量属性nums[i]。需要三层循环。

//N为物品数目
//W为背包容量
//num[]为每个物品的数目
//weights[]为每个物品的体积
//values[]为每个物品的价值
public class DuoChongBags {
    public static void main(String[] args) {
        int N = 7;
        int W = 6;
        int[] num = new int[]{1,1,1,1,1,1,1};
        int[] weights = new int[]{3,4,3,9,4,5,4};
        int[] values = new int[]{8,2,1,7,1,18,4};
        System.out.println(multiKnapack(N, W, num, weights, values));
    }

    public static int multiKnapack(int N, int W, int[] num, int[] weights, int[] values) {
        int[] dp = new int[W + 1];
        for (int i = 1; i <= N; i++) {
            int M = num[i - 1], w = weights[i - 1], v = values[i - 1];
            for (int j = W; j >= w; j--) {
                for (int k = 0; k <= M && k * w <= j; k++) {
                    dp[j] = Math.max(dp[j], dp[j - k * w] + k * v);
                }
            }
        }
        return dp[W];
    }
}