01背包&完全背包

/**
 * @author: hujy
 * @create: 2023-09-22 20:49
 * @version: V1.0
 * Description:
 */
public class Main2 {
    public static void main(String[] args) {
        test01PackWay1();
        test01PackWay2();
        testCompletePackAnotherWay();
        testCompletePackAnotherWay2();
    }

    /**
     * 01背包（二维数组实现）
     * 问题：有N件物品，每件可以只能用1次，求解将哪些物品装入背包里物品价值综合最大
     */
    public static void test01PackWay1() {
        int[] weight = {1, 3, 4};
        int[] value = {15, 20 ,30};
        int n = weight.length; // 物品个数
        int bagSize = 4; //背包容量
        int[][] dp = new int[n][bagSize + 1];
        // 初始化第一行
        for (int i = weight[0]; i <= bagSize; i++) {
            dp[0][i] = value[0];
        }
        // 先遍历物品后遍历背包方式实现
        for (int i = 1; i < weight.length; i++) {
            for (int j = 1; j <= bagSize; j++) {  // 注意 背包容量取值范围
                // 注意，当采用二维数组时，要用if,else，不能直接把j赋值为weight[i]
                // 因为这样会使 dp[i][j] 无法 继承dp[i-1][j]的值，导致最终计算出错！！！
                if (weight[i] > j){
                    dp[i][j] = dp[i-1][j];
                }else{
                    dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i]);
                }
            }
        }
        System.out.println(dp[n-1][bagSize]);
    }

    /**
     * 01背包（一维数组[滚动数组]实现）
     * 问题：有N件物品，每件可以只能用1次，求解将哪些物品装入背包里物品价值综合最大
     */
    public static void test01PackWay2() {
        int[] weight = {1, 3, 4};
        int[] value = {15, 20 ,30};
        int bagSize = 4;
        int[] dp = new int[bagSize + 1];
        for (int i = weight[0]; i <= bagSize; i++) {
            dp[i] = value[0];
        }
        /**
         * 01背包用滚动数组实现，遍历背包容量时需要倒序，防止同一个物品加入多次背包
         * 如果遍历背包容量时不倒序遍历，那么当i固定（即物品固定），循环遍历背包容量时，每种容量的背包都尝试把物品i放进去，导致重复放置物品i
         * 对于采用二维数组解决01背包问题，由于每次都是取的上一次的结果（dp[i-1][]），所以不会出现一个物品多次加入背包的情况
         * 因此对于完全背包问题，使用滚动数组可以正序遍历，即可AC
         */
        for (int i = 1; i < weight.length; i++) {
            for (int j = bagSize; j >= weight[i]; j--) {
                dp[j] = Math.max(dp[j], dp[j-weight[i]] + value[i]);
            }
        }
        System.out.println(dp[bagSize]);
    }

    /**
     * 完全背包（滚动数组实现）
     * 问题：有N件物品，每件可以使用无限次，求解将哪些物品装入背包里物品价值综合最大
     */
    public static void testCompletePackAnotherWay() {
        int[] weight = {1, 3, 4};
        int[] value = {15, 20 ,30};
        int bagWeight = 4;
        int[] dp = new int[bagWeight + 1];
        for (int i = weight[0]; i <= bagWeight; i++) {
            dp[i] = value[0];
        }
        // 多重背包，滚动数组实现时，直接正序遍历即可
        for (int i = 1; i < weight.length; i++) {
            for (int j = weight[i]; j <= bagWeight; j++) {
                dp[j] = Math.max(dp[j], dp[j-weight[i]] + value[i]);
            }
        }
        System.out.println(dp[bagWeight]);
    }

    /**
     * 完全背包（二维数组实现）
     * 问题：有N件物品，每件可以只能用1次，求解将哪些物品装入背包里物品价值综合最大
     */
    public static void testCompletePackAnotherWay2() {
        int[] weight = {1, 3, 4};
        int[] value = {15, 20 ,30};
        int n = weight.length; // 物品个数
        int bagSize = 4; //背包容量
        int[][] dp = new int[n][bagSize + 1];
        // 初始化第一行
        for (int i = weight[0]; i <= bagSize; i++) {
            dp[0][i] = value[0];
        }
        // 先遍历物品后遍历背包方式实现
        for (int i = 1; i < weight.length; i++) {
            for (int j = 1; j <= bagSize; j++) {  // 注意 背包容量取值范围
                // 注意，当采用二维数组时，要用if,else，不能直接把j赋值为weight[i]
                // 因为这样会使 dp[i][j] 无法 继承dp[i-1][j]的值，导致最终计算出错！！！
                if (weight[i] > j){
                    dp[i][j] = dp[i-1][j];
                }else{
                    dp[i][j] = Math.max(dp[i-1][j], dp[i][j-weight[i]] + value[i]);
                }
            }
        }
        System.out.println(dp[n-1][bagSize]);
    }
}