[算法] 动态规划之01背包问题

引入

01背包问题

（题目源自AcWing）

有 N件物品和一个容量是 V的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

数据范围

0<N,V≤1000
0<vi,wi≤1000

输入样例

4 5
1 2
2 4
3 4
4 5

输出样例

8

分析

01背包问题的特点为每个物品只能用一次（要么0要么1）
动态规划分为两步：状态表示与状态计算
让我们先从最朴素的方法开始想。

状态表示

一般我们用两维数组表示状态，即dp[i][j]
这里的状态其实表示的都是一个集合，我们要搞清楚的就是我们所定义的数组的集合所代表的是什么意思
当然，在此处，即我们的01背包问题中，这个集合表示的就是所有选法。
一般我们在dp[i][j]存的是这个集合的一个属性，比如最大值，最小值，数量等等，在此背包问题中表示的是最大值。
好了，那么我们在此处定义的dp[i][j]，表示是前i个物品中选，总体积为j的所有选法的最大值。
加以定义

        int[] volume = new int[n + 1];  //体积（重量）
        int[] weight = new int[n + 1];  //价值（权重）

状态计算

状态计算对应的是集合划分，在dp[i][j]中，我们可以划分出两类不同的集合，即：包含第i个和不包含第i个。
不包含第i个的集合，那不就是从(i - 1)个物品选，且体积不超过 j 的集合吗？即

dp[i][j] = dp[i - 1][j];

那么包含第i个物品的集合呢?这好像令人毫无头绪。
那我们继续想，这个集合的最大值他一定是含有第i个，那我们抛开这个第i个，暂时去掉它，这并不会影响我们计算dp[i][j]（后期加上即可），我本来想要求出的东西是包含第i个物品且体积不超过j的集合，那么当我抛出这个第i个物品时，就变成不包含第i个物品且体积不超过 （j - vi） 的集合在加上 wi，我们得以巧妙地转换。（注意：j需要满足 j >= volumn[i]）
那这样太好了我们就能蹭蹭写出：

        //二维
        //分成两个集合，即包含i和不包含i
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if(j >= volume[i]){
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - volume[i]] + weight[i]);
                // 前一个为不包含i的情况，j容量下，选择前 i - 1 物品的最大价值
                //后一个为包含i，即转化为：选择在 i - 1 个物品最大价值，在加上第i个物品的价值
                }else{
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

过了！

但是耗时太长，我们能不能进一步优化呢？
当然可以 不然我就不会这么问了

一维优化！

当我们看状态转移方程时，计算dp[i]这一层时，只用到了 dp[i - 1]这一层，所以我们可以用滚动数组来做
如果 forj 这行代码如果顺序的话，因为 (j - vi) 肯定小于 j ，所以再算dp[j]之前,他是在第 i 层被算过一次了，也就是 二维dp中的 dp[i][j - wi], 但是我们所要的是 dp[i - 1][ j - wi]， 所以我们要逆序遍历j

        for (int i = 1; i <= n; ++i) {
            for (int j = m; j >= volume[i]; --j) {
       //选择逆序遍历，这样不会让 i - 1 被覆盖，dp[j - volume[i]] 一定先被计算，
       //所以结果是第i层的而非 i - 1 层
                dp[j] = Math.max(dp[j], dp[j - volume[i]] + weight[i]);     //
            }
        }

过了！确实快了一些

但是这也很慢，所以我加入快速读入，没加快速输出。

差距！

AC代码：

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

/**
 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi ，价值是 wi 。
 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。
 */
public class Main {
    public static void main(String[] args) throws IOException {
        Input in = new Input();
        int n = in.nextInt();
        int m = in.nextInt();
        int[] volume = new int[n + 1];  //体积（重量）
        int[] weight = new int[n + 1];  //价值（权重）
        for (int i = 1; i <= n; ++i) {
            volume[i] = in.nextInt();
            weight[i] = in.nextInt();
        }

        /**二维*/
       /* int[][] dp = new int[n + 1][m + 1];//dp[i][j]表示在 只能选择前i个物品，背包容量为j的情况下，背包中物品的最大价值
        //二维
        //分成两个集合，即包含i和不包含i
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if(j >= volume[i]){
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - volume[i]] + weight[i]);
                // 前一个为不包含i的情况，j容量下，选择前 i - 1 物品的最大价值
                //后一个为包含i，即转化为：选择在 i - 1 个物品最大价值，在加上第i个物品的价值
                }else{
                    dp[i][j] = dp[i - 1][j];
                }

            }
        }
        System.out.println(dp[n][m]);*/
    /** 一维*/
        int[] dp = new int[m + 1];
        for (int i = 1; i <= n; ++i) {
            for (int j = m; j >= volume[i]; --j) {
                //选择逆序遍历，这样不会让 i - 1 被覆盖，dp[j - volume[i]] 一定先被计算，所以结果是第i层的而非 i - 1 层
                dp[j] = Math.max(dp[j], dp[j - volume[i]] + weight[i]);     //
            }
        }
        System.out.println(dp[m]);
    }
}


class Input {
    StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    public int nextInt() throws IOException {
        in.nextToken();
        return (int)in.nval;
    }
}