01背包问题（模板）

一、题目描述

描述

你有一个背包，最多能容纳的体积是V。

现在有n个物品，第i个物品的体积为vi,价值为wi。

（1）求这个背包至多能装多大价值的物品？

（2）若背包恰好装满，求至多能装多大价值的物品？

输入描述：

第一行两个整数n和V，表示物品个数和背包体积。

接下来n行，每行两个数vi和wi​，表示第i个物品的体积和价值。

1≤n,V,vi,wi≤10001≤n,V,vi​,wi​≤1000

输出描述：

输出有两行，第一行输出第一问的答案，第二行输出第二问的答案，如果无解请输出0。

示例1

输入：

3 5
2 10
4 5
1 4

输出：

14
9

说明：

装第一个和第三个物品时总价值最大，但是装第二个和第三个物品可以使得背包恰好装满且总价值最大。 

示例2

输入：

3 8
12 6
11 8
6 8

输出：

8
0

说明：

装第三个物品时总价值最大但是不满，装满背包无解。 

题目链接：

【模板】01背包_牛客题霸_牛客网

二、算法思路 （动态规划）

解决第一问：

1、状态表示

dp[i][j] 表示：从前 i 个物品中挑选， 总体积不超过 j ，所有的选法中，能挑选出来的最大价值。 

2、 状态转移方程

对于选 i 物品的情况，要判断一下 j - v[i] >= 0.

3、初始化

我们多加一行，方便我们的初始化：从i、j下标为1的位置开始填表，对于i、j下标为0，即第一行，第一列，均初始化为0即可。因为第一行代表从0个物品中挑选，第一列代表挑选出来的总体积要不超过0。

4、填表顺序

从上往下填表。

5、返回值

 返回dp[n][V].

解决第二问：

第二问要求背包恰好装满，因为有可能凑不齐 j 体积的物品，因此我们把不合法的状态设置为 -1。

1、状态表示

dp[i][j] 表示：从前 i 个物品中挑选， 总体积正好等于 j ，所有的选法中，能挑选出来的最大价值。 

2、 状态转移方程

跟第一问一样，dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - v[i]] + w[i]) 。 但是在使用 dp[i - 1][j - v[i]] 的时候，不仅要判断 j >= v[i] ，又要判断 dp[i - 1][j - v[i]] 表示的情况是否存在，

也就是 dp[i - 1][j - v[i]] != -1 。

3、初始化

我们多加一行，方便我们的初始化：

• 第一个格子为 0 ，因为正好能凑齐体积为 0 的背包；
• 但是第一行后面的格子都是 -1 ，因为没有物品，无法满足体积大于 0 的情况。

4、填表顺序

从上往下填表。

5、返回值

由于最后可能凑不成体积为 V 的情况，因此返回之前需要判断一下。

三、代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int n, V;
        int N = 1001; //这里N的值要注意一下，因为我们解题时，物品下标是从1开始的
        int[] v = new int[N];
        int[] w = new int[N];
        int[][] dp = new int[N][N];
        Scanner in = new Scanner(System.in);
        //输入n,V
        n = in.nextInt();
        V = in.nextInt();

        //输入n组v,w
        for (int i = 1; i <= n; i++) {
            v[i] = in.nextInt();
            w[i] = in.nextInt();
        }

        //填dp表
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= V; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j - v[i] >= 0) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
                }
            }
        }

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

        //第二问，求背包恰好装满的情况
        //先将dp表清零
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= V; j++) {
                dp[i][j] = 0;
            }
        }

        //初始化
        for (int j = 1; j <= V; j++) {
            dp[0][j] = -1;
        }
        //填表
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= V; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j - v[i] >= 0 && dp[i - 1][j - v[i]] != -1) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
                }
            }
        }
        System.out.println(dp[n][V] == -1 ? 0 : dp[n][V]);
    }
}

四、优化

空间优化：

背包问题基本上都是利用 「滚动数组」 来做空间上的优化。

在01背包问题中，优化的结果为：

• 删掉所有的横坐标；
• 修改一下 j 的遍历顺序。

优化之后的代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        int n, V;
        int N = 1001;  //这里N的值要注意一下，因为我们解题时，物品下标是从1开始的
        int[] v = new int[N];
        int[] w = new int[N];
        int[] dp = new int[N];
        Scanner in = new Scanner(System.in);
        //输入n,V
        n = in.nextInt();
        V = in.nextInt();

        //输入n组v,w
        for (int i = 1; i <= n; i++) {
            v[i] = in.nextInt();
            w[i] = in.nextInt();
        }
            
        //填dp表，注意j的遍历顺序
        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]);

        //第二问，求背包恰好装满的情况
        //先将dp表清零
        for (int j = 1; j <= V; j++) {
                dp[j] = 0;
        }

        //初始化
        for (int j = 1; j <= V; j++) {
            dp[j] = -1;
        }

        //填dp表，注意j的遍历顺序
        for (int i = 1; i <= n; i++) {
            for (int j = V; j >= v[i]; j--) {
                if (dp[j - v[i]] != -1) {
                    dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
                }
            }
        }
        System.out.println(dp[V] == -1 ? 0 : dp[V]);
    }
}