动态规划：01背包问题

---

题目

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之间的区别所在。

1. 状态定义
   $dp[i][j]$:表示前$i$件物品可选、背包容积为$j$下的最大价值
2. 状态转移
   $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\ast c\right)$
空间复杂度：$O\left(n\ast 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\ast c\right)$
空间复杂度：$O\left(c\right)$

练习题目

LeetCode 416. 分割等和子集
LeetCode 474. 一和零
LeetCode 494. 目标和
LeetCode 879. 盈利计划

Reference

背包九讲