背包问题（01背包）动态规划二维dp+一维优化版

背包问题（01背包）动态规划

本文包含动态规划解决背包问题的二维dp数组版本及优化后的一维dp数组版本，代码均用Java实现。

题目描述

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

第 i 件物品的体积是 vi，价值是 wi。

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

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

数据范围
0<N,V≤1000

0<vi,wi≤1000
输入样例

4 5
1 2
2 4
3 4
4 5

输出样例

8

二维数组思路

先来看二维数组f(i,j)解决。
f(i,j)表示的为前i个物品，任意放在容量大小为j的背包当中的各种方式，但其要取最大值，即前i个物品放在容量为j 的背包中的所有存放方式的最大价值。

由此可以退当前f(i,j)的状态由前i-1个物品的存放方式和存不存放第i个物品来决定。

不存放第i个物品的话则
f(i,j)=f(i-1,j)

若要存放第i个物品，则还要满足前提条件j>=v(i)；此时
f(i,j)=f(i-1,j-v(i))+w(i)

具体分析方式如下图：

接着判断数组的初始化的值，而f(0,j)表示没有选任何物品则全为0（这里的物品默认从1开始），而f(i,0)表示背包没有任何空间，也全部为0；

二维数组的值f(i,j)由刚刚分析可得均由之前的数来决定，则不用可以去做任何初始化，因为没有任何影响。

接着思考遍历顺序，因为二维数组的值f(i,j)由刚刚分析可得均由之前的数来决定，则我们采取从小到大的遍历顺序即可。

具体代码：

import java.util.Scanner;

public class Main {
    static int[] v;//物品体积
    static int[] w;//物品价值
    static int N;//物品数量
    static int V;//背包最大容量
    static int[][] f;//f[i][j]数组，值表示前i个物品放在容量为j的背包中的最大价值
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        N=scan.nextInt();
        V=scan.nextInt();
        v=new int[N+5];
        w=new int[N+5];
        f=new int[N+5][V+5];
        for (int i = 1; i <=N; i++) {
            v[i]= scan.nextInt();
            w[i]= scan.nextInt();
        }
        for (int i = 1; i <= N; i++) {
            for (int j = 0; j <= V; j++) {
                if (j<v[i]){//当前容量无法存i
                    f[i][j]=f[i-1][j];
                }
                else {//可以存i的情况下求最大值
                    f[i][j]=Math.max(f[i-1][j],f[i-1][j-v[i]]+w[i]);
                }
            }
        }
        System.out.println(f[N][V]);
    }
}

优化内存版一维数组思路

这里去考虑优化动态规划的内存开销。
我们所求的f[i][j]只有两种求得方式：

f[i][j]=f[i-1][j];
f[i][j]=Math.max(f[i-1][j],f[i-1][j-v[i]]+w[i]);

可以看出第一种情况下只跟前一项有关，因此我们没必要保存每次求出来的值，我们让i从小到大遍历即可，即可优化为f[j]=f[j];而让其值动态更新即可。

f[i][j] = f[i - 1][j];  // 优化前
f[j] = f[j];            // 优化后，该行自动成立，可省略。

难点在于当我们采用第二种赋值方式dp[i][j]=Math.max(dp[i-1][j],dp[i-1][j-v[i]]+w[i]);可以思考优化为

f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);  // 优化前
f[j] = max(f[j], f[j - v[i]] + w[i]);                   // 优化后

如何去找到f[j-v[i]]+w[i]这个值，f[j-v[i]]的值如果按照原遍历随着j++一定会先求出来，那当我们在求f[j]时实际用的可能是f[i][j-v[i]]，可以思考如果我们直接简化为一维数组的话，f[j-v[i]]的值会优先被污染，我们要采用的是i上一层的f[j-v[i]]的值，因此可以让j逆序从大到小遍历即可。

一维代码

import java.util.Scanner;
public class Main {
   static int[] v;//物品体积
    static int[] w;//物品价值
    static int N;//物品数量
    static int V;//背包最大容量
    static int[][] f;//f[i][j]数组，值表示前i个物品放在容量为j的背包中的最大价值
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        N=scan.nextInt();
        V=scan.nextInt();
        v=new int[N+5];
        w=new int[N+5];
        f=new int[N+5][V+5];;

        for (int i = 1; i <= N; i++) {
            v[i]= scan.nextInt();//这里发现当前数据只跟前面的数据有关，因此可以一边读入一边操作
            w[i]= scan.nextInt();
            for (int j = V; j >= v[i]; j--) {
                f[j]=Math.max(f[j],f[j-v[i]]+w[i]);
            }
        }
        System.out.println(f[V]);
    }
}