本文已参与「新人创作礼」活动，一起开启掘金创作之路。

题目

01背包问题

有 $N$ 件物品和一个容量是 $V$ 的背包。每件物品只能使用一次。

第 $i$ 件物品的体积是 $v_{i}$ ，价值是 $w_{i}$ 。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。

输出最大价值。

输入格式

第一行两个整数， $N$ ， $V$ ，用空格隔开，分别表示物品数量和背包容积。

接下来有 $N$ 行，每行两个整数 $v_{i}$ , $w_{i}$ ，用空格隔开，分别表示第 $i$ 件物品的体积和价值。

输出格式

输出一个整数，表示最大价值。

数据范围

$0< N,V\le 1000$

$0< v_{i},w_{i} \le 1000$

输入样例

4 5
1 2
2 4
3 4
4 5

输出样例

8

解题思路

01背包问题的特点是：每种物品仅有一件，可以选择放或者不放。

方法一：递归

考虑暴力搜索，穷举每一种选择情况，然后对所有情况，求最大值，可以画出如下的递归树：

在这里插入图片描述

通过上图，可以很容易得出一个递归表达式：

$F\left ( n,C \right ) =max(F\left ( n-1,C \right ), F\left ( n-1,C-v[i] \right ) +w[i] )$

因此，基于递归的代码如下：

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        int n = cin.nextInt();                 // 物品数量
        int c = cin.nextInt();                 // 背包容积
        int[] v = new int[n];                // 物品的体积
        int[] w = new int[n];                // 物品的价值
        for (int i = 0; i < n; i++) {
            v[i] = cin.nextInt();
            w[i] = cin.nextInt();
        }
        int res = bestValue(v, w, n-1, c);
        System.out.println(res);
    }
    // 用 [0, index] 的物品， 填充容积为c的背包的最大价值
    public static int bestValue(int[] v, int[] w, int index, int c) {
        if (index < 0 || c <= 0) return 0;
        
        int res = bestValue(v, w, index-1, c);      // 不考虑第index件物品
        if (c >= v[index]) {                        // 考虑第index件物品
            res = Math.max(res, bestValue(v, w, index-1, c-v[index])+w[index]);
        }
        return res;
    }
}

运行结果

Time Limit Exceeded

方法二：记忆化搜索/备忘录

在方法一的递归树中，会有很多子问题被重复计算。为了避免重复的计算，我们将每个子问题的答案存在一个数组中进行记忆化，如果下次还要计算这个问题的值直接从数组中取出返回即可，这样能保证每个子问题最多只被计算一次。

import java.io.*;
import java.util.*;

public class Main {
    // 备忘录
    // memo[n][c]表示有前n件物品可选、背包容积为c时的最大价值
    static int[][] memo;                              
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        int n = cin.nextInt();                 // 物品数量
        int c = cin.nextInt();                 // 背包容积
        int[] v = new int[n];                // 物品的体积
        int[] w = new int[n];                // 物品的价值
        for (int i = 0; i < n; i++) {
            v[i] = cin.nextInt();
            w[i] = cin.nextInt();
        }
        memo = new int[n][c+1];
        for (int i = 0; i < memo.length; i++) {
            for (int j = 0; j < memo[0].length; j++) {
                memo[i][j] = -1;              // 初始化
            }
        }
        int res = bestValue(v, w, n-1, c);
        System.out.println(res);
    }
    // 用 [0, index] 的物品， 填充容积为c的背包的最大价值
    public static int bestValue(int[] v, int[] w, int index, int c) {
        if (index < 0 || c <= 0) return 0;
        
        if(memo[index][c] != -1) return memo[index][c];
        
        int res = bestValue(v, w, index-1, c);      // 不考虑第index件物品
        if (c >= v[index]) {                        // 考虑第index件物品
            res = Math.max(res, bestValue(v, w, index-1, c-v[index])+w[index]);
        }
        memo[index][c] = res;
        return res;
    }
}

方法三：动态规划

方法二已经满足题目的要求。但是对于这样的一个递归代码，我们更习惯转化为递推，将自顶向下的思路转换为自底向上，这也是记忆化搜索和DP之间的区别所在。

在这里插入图片描述

状态定义

$dp[i][j]$ :表示前 $i$ 件物品可选、背包容积为 $j$ 下的最大价值

状态转移

$dp[i][j]=max\left ( dp[i-1][j],dp[i-1][j-v[i]]+w[i] \right )$

import java.io.*;
import java.util.*;

public class Main {
                            
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        int n = cin.nextInt();                 // 物品数量
        int c = cin.nextInt();                 // 背包容积
        int[] v = new int[n];                  // 物品的体积
        int[] w = new int[n];                  // 物品的价值
        for (int i = 0; i < n; i++) {
            v[i] = cin.nextInt();
            w[i] = cin.nextInt();
        }
        //  dp[i][j]表示：前i件物品可选、背包容积为j下的最大价值
        int[][] dp = new int[n][c+1];
        
        // 边界条件：有1件物品可选且背包容积为j时的最大价值
        for (int j = 0; j <= c; j++) {
            dp[0][j] = (j >= v[0] ? w[0] : 0);
        }
        
        for (int i = 1; i < n; i++) {
            for (int j = 0; j <= c; j++) {
                // 不考虑第i个物品, 前i-1件物品放入容量为j的背包中
                dp[i][j] = dp[i-1][j];
                // 考虑第i件物品，前i-1件物品放入剩下的容量为j-v[i]的背包中
                if ( j >= v[i]) {
                    dp[i][j] = Math.max(dp[i][j], dp[i-1][j-v[i]]+w[i]);
                }
            }
        }
        
        System.out.println(dp[n-1][c]);
    }

}

时间复杂度： $O\left ( n*c \right )$
空间复杂度： $O\left ( n*c \right )$

空间优化

在上述代码中，定义了一个二维的 $dp$ 数组，考虑能否只用一维数组来保证第 $i$ 次循环结束后 $dp[j]$ 中表示的状态就是我们定义的状态 $dp[i][j]$ ?

在实际的递推中我们发现， $dp[i][j]$ 是由 $dp[i-1][j]$ 和 $dp[i-1][j-v[i]]$ 两个子问题递推而来，如果在每次主循环中我们以 $j=c...0$ 的递减顺序计算 $dp[j]$ ，这样就能保证递推 $dp[j]$ 时 $dp[j-v[i]]$ 保存的是状态 $dp[i-1][j-v[i]]$ 的值。

import java.io.*;
import java.util.*;

public class Main {
                            
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        int n = cin.nextInt();                 // 物品数量
        int c = cin.nextInt();                 // 背包容积
        int[] v = new int[n];                  // 物品的体积
        int[] w = new int[n];                  // 物品的价值
        for (int i = 0; i < n; i++) {
            v[i] = cin.nextInt();
            w[i] = cin.nextInt();
        }
        
        int[] dp = new int[c+1];
        
        // 边界条件：有1件物品可选且背包容积为j时的最大价值
        for (int j = 0; j <= c; j++) {
            dp[j] = (j >= v[0] ? w[0] : 0);
        }
        
        for (int i = 1; i < n; i++) {
            for (int j = c; j >= v[i]; j--) {   // 若j<w[i]，则背包中能存放的最大价值不变
                dp[j] = Math.max(dp[j], dp[j-v[i]]+w[i]);
            }
        }
        
        System.out.println(dp[c]);
    }

}

时间复杂度： $O\left ( n*c \right )$
空间复杂度： $O\left ( c \right )$

练习题目

Reference

背包九讲

背包问题：01背包问题

题目