背包问题之01背包、完全背包

#背包问题九讲

0-1背包

题目

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。
输入格式 :
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式 :
输出一个整数，表示最大价值。
数据范围 :
0<N,V≤1000
0<vi,wi≤1000

01背包问题的特点在于每个物品只有一个，这是一道极其经典的动态规划（dp）问题。动态规划问题最重要的就是推导出状态转移方程。让我们来分析一下。

“将第i件物品放入背包”，那么如果只考虑第i件物品的方式策略，那么就只和第i-1件物品有关了，如果是放第i件物品，那么问题就转化为：“前i-1件物品放入容量为j的背包中”，此时能够获得的最大价值就是f[i-1][j-v[i]]，也就是第i-1件物品放入容量为j（原来的总容量）减去v[i]（第i件物品的占容）产生的最优价值，再加上放通过入第i件物品增加的价值w[i]。 那么放入第i件物品产生的最大价值就是要在”放“，或者是”不放“中选择了，”不放“的话，产生的价值就是f[i-1][j]，”放“的话，产生的最大价值就是,f[i-1][j-v[i]]+w[i])。从中选择较大值
在代码编写上，可以对边界控制进行一些优化，比如数组初始化为N+1，V+1大小的数组，这样更容易控制边界条件。

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int V = sc.nextInt();
        //存储物品体积,此处处理为N+1是为了之后边界更好处理
        int[] v = new int[N+1];
        //存储物品价值
        int[] w = new int[N+1];
        for(int i = 1;i<=N;i++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        //此时的dp[i][j] 表示当选择的物品只有前i件且物品栏容量为j时的最大价值
        int[][] dp = new int[N+1][V+1];
        dp[0][0] = 0;
        for(int i = 1;i<=N;i++){
            for(int j = 1;j<=V;j++){
                if(j>=v[i]){
                    //不选或者是选择
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);
                }else{
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        System.out.println(dp[N][V]);
    }
}

此处可以看到，每次状态转移的时候只需要借助上一行的数据，比如dp[i][j]可能需要的是dp[i-1][j-v[i]]和dp[i-1][j]的数据，因此如果从前往后递推的话，不能得到dp[i-1][j-v[i]]的数据(只能拿到dp[i][j-v[i]])的数据，因此只能逆序更新，即更新i再更新i-1。

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int V = sc.nextInt();
        //存储物品体积,此处处理为N+1是为了之后边界更好处理
        int[] v = new int[N+1];
        //存储物品价值
        int[] w = new int[N+1];
        for(int i = 1;i<=N;i++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        int[] dp = new int[V+1];
        for(int i = 1;i<=N;i++){
            //从后往前滚动递推
            for(int j = V;j>=v[i];j--){
                dp[j] = Math.max(dp[j], dp[j-v[i]] + w[i]);
            }
        }
        System.out.println(dp[V]);
    }
}

完全背包问题

题目：

有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。第 i 种物品的体积是 vi，价值是 wi。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 种物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000

解析：

完全背包问题，完全是基于01背包的扩展，问题就在于完全背包的物品件数是不限制的。所以相较于前面的01背包的状态转移方程：dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);应该扩展为dp[i][j]=max{dp[i-1][j],dp[i-1][j-v[i]]+w[i],dp[i-1][j-2v[i]+2w[i]...dp[i-1][j-k*v[i]]+k*w[i]}
但是如果计算的时候使用这种方式的话 复杂度将会扩张。
我们可以看到
dp[i][j-v[i]]=max{dp[i-1][j-v[i]],dp[i-1][j-2v[i]]+w[i],....dp[i-1][j-(k+1)*v[i]]+k*w[i]},因此
dp[i][j-v[i]]+w[i]=max{dp[i-1][j-v[i]+w[i],dp[i-1][j-2v[i]]+2w[i]+....+dp[i-1][j-k*v[i]]+k*w[i]}
因此，可以得到dp[i][j]=max{dp[i-1][j],dp[i][j-v[i]]+w[i]}这一个状态转移公式。

代码：

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        int V = sc.nextInt();
        //存储物品体积,此处处理为N+1是为了之后边界更好处理
        int[] v = new int[N+1];
        //存储物品价值
        int[] w = new int[N+1];
        for(int i = 1;i<=N;i++){
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        int[][] dp = new int[N+1][V+1];
        for(int i = 1;i<=N;i++){
            for(int j = 1;j<=V;j++){
                if(v[i]<=j){
                    dp[i][j]=Math.max(dp[i-1][j],dp[i][j-v[i]]+w[i]);
                }else{
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        System.out.println(dp[N][V]);
    }
}

至于完全背包问题的优化，就交给读者自己去尝试一下吧，原理和之前的01背包的优化基本上一致。写出代码的小伙伴可以到https://www.acwing.com
该网站的Online Judge对自己的代码进行评判。