01背包、完全背包、多重背包模板

三种背包概念

01背包（ZeroOnePack）: 有N件物品和一个容量为V的背包。每种物品均只有一件。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。
完全背包(CompletePack): 有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
多重背包(MultiplePack): 有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

这三种背包问题的区别在于：01背包是只能每种物品只有一件可以拿，完全背包每种物品可以拿无数次，多重背包每种物品可以拿有限次。

模板

• 01背包
  背包容量：V
  物品种类：N
  物品所占空间（费用）：c[N]
  物品价值：w[i]

这里设置dp[i][v]为对于前面i件商品放入容量为v的背包中能获得的最大价值。对于第i件商品，有两种情况，即取第i件商品或不取。对于取商品，dp[i][v]=dp[i-1][v-c[i]]+w[i]，表示当前的最大价值等于前面第i-1件物品放入容量为v-c[i]的背包中能获得的最大价值加上当前物品的价值；而对于不取商品，dp[i][v]=dp[i-1][v]，即当前最大价值等于取前面第i-1件商品放入容量为v的背包中。
状态转移方程如下：

dp[i][V] = Math.max(dp[i-1][V],dp[i-1][v-c[i]]+w[i]);

为了简化上述转移方法，在循环时以物品种类为外圈，以背包容量为内圈，从V遍历到0，简化为：

dp[V] = Math.max(dp[V],dp[v-c[i]]+w[i]);

模板如下：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int N = sc.nextInt(); //物品个数
            int V = sc.nextInt(); //背包容量
            int[] c = new int[N]; //每个商品的花费（所占容量）
            int[] w = new int[N]; //每个商品的价值
            for (int i = 0; i < N; i++) {
                c[i] = sc.nextInt();
                w[i] = sc.nextInt();
            }

            int[] dp = new int[V + 1];
            for (int i = 0; i < N; i++) {
                for (int j = V; j >= 1; j--) {
                    if (c[i] <= j) {
                        dp[j] = Math.max(dp[j], dp[j - c[i]] + w[i]);
                    }
                }
            }

            System.out.println(dp[V]);
        }
    }
}

• 完全背包
  背包容量：V
  物品种类：N
  物品所占空间（费用）：c[N]
  物品价值：w[i]
  这种题的特点是一个物品可以拿无数次。这里假设当前物品i拿了k次，k的范围为：0 <= k * c[i] <= v，这里的0表示不拿。
  动态转移方程如下：

dp[i][v] = Math.max(dp[i-1][v-k*c[i]]+k*w[i]) ，其中0 <= k * c[i] <= v

转换为一维数组为：注意这里和01背包的区别是内循环为顺序

for i : 0...N
	for j : 1...V
		dp[v] = Math.max(dp[v],dp[v-c[i]]+w[i]) ，其中0 <= k * c[i] <= v

模板如下：

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int N = sc.nextInt(); //物品个数
            int V = sc.nextInt(); //背包容量
            int[] c = new int[N]; //每个商品的花费（所占容量）
            int[] w = new int[N]; //每个商品的价值
            for (int i = 0; i < N; i++) {
                c[i] = sc.nextInt();
                w[i] = sc.nextInt();
            }

            int[] dp = new int[V + 1];
            for (int i = 0; i < N; i++) {
                for (int j = 1; j <= V; j++) {
                    if (c[i] <= j) {
                        dp[j] = Math.max(dp[j], dp[j - c[i]] + w[i]);
                    }
                }
            }

            System.out.println(dp[V]);
        }
    }
}

• 多重背包
  有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。
  其状态转移方程和完全背包类似，因为第i种物品有n[i]件，所以一共了n[i]+1种策略，即取0件、1件…n[j]件，状态转移方程如下：

dp[i][v] = Math.max(dp[i-1][v-k*c[i]]+k*w[i]) (0 <= k <= n[i])

初始化条件为：

dp[i][0] = 0;
dp[0][v] = 0

背包容量：V
物品种类：N
设定一个类储存物品：Goods
物品数组：goods[]

class Goods{
    private int count;//物品的个数
    private int cost;//物品的花费
    private int worth;//物品的价值
}

一共三层循环：

for i 0 ... N
   for j 1....V
   		for k 0...goods[i].count
   			dp[i][j] = Math.max(dp[i][j],dp[i-1][v-k*goods[i].cost]+k*goods[i].worth);

模板如下：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int N = sc.nextInt(); //物品个数
            int V = sc.nextInt(); //背包容量
            Goods[] goods = new Goods[N];
            for (int i = 0; i < N; i++) {
                goods[i] = new Goods(sc.nextInt(), sc.nextInt(), sc.nextInt());
            }

            int[][] dp = new int[N][V + 1];


            for (int i = 0; i < N; i++) {
                for (int j = 1; j <= V; j++) {
                    for (int k = 0; k < goods[i].getCount(); k++) {
                        dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - k * goods[i].getCost()] + k * goods[i].getWorth());
                    }
                }
            }

            System.out.println(dp[N - 1][V]);
        }
    }
}