背包问题：货物有重量或体积，有价值，书包最多装bag这么多，请问书包能最大装多少价值的货物

背包问题：货物有重量/体积，有价值，书包最多装bag这么多，请问书包能最大装多少价值的货物？

提示：动态规划DP1：从左往右的尝试模型

---

题目

背包问题：货物有重量/体积w数组，有价值v数组，书包最多装bag这么多，
请问书包能最大装多少价值的货物？

---

一、审题

示例：
w=5 10 7
v=5 10 7
不妨设俩一样
bag最大装14

则：咱们从左往右，i=0–N-1，每一个位置都试一下，装呢，还是不要装？

当决定装的过程中，发现总量大于bag，方案失效，返回-1
否则就可以继续装，记录总价值
最后发现，案例中，有一条路径可以得到最大值值
0不要，1要，2要，最大价值12

---

2个变量，多带一个bag常量

其实案例那已经说得很明确了
这是一个DP1：从左往右的尝试模型：即i从0–N-1【从左往右呗】上遍历，决定i位置的物品要还是不要

定义f(w,v,bag,i,j)：
目前已经从0–i-1范围内装了j这么多（重量，体积都行）
现在从i–N-1范围内决定，要i，还是不要i的物品，能得到的最大价值是多少？
w和v和bag都是题目给定的，为了题目说明方便，简单，我们直接令f(w,v,bag,i,j）=f(i,j)

在决定过程中：
（2）一旦发现你已经装了的总量j>bag了，书包装不下了，你这方案废了，返回-1，无效！——这个条件一定得在前面，否则i=N已经让你返回了，不行的。
（1）一旦发现你i=N了，越界，没有货物了，多增加的价值就是0，返回0
（3）如果还能装下：
——咱不要i这个物品，那直接去i+1位置决定就行，调用f(i +1,j)，j没变，因为你没要

——咱要i这个物品，那调用f(i +1,j +w[i])，j多了i的重量，下一次去i+1决定，但很可能这个返回值是-1，那就放弃，不是-1那就可以将v[i]累加f(i +1,j +w[i])，作为增加的价值。
最终上面这两种情况，谁得到的价值更大，要谁，返回。作为当前决定i之后得到的最大价值。

懂了这个思想了吗，从左往右决定i位置要还是不要，我们能得到的最大价值，返回，这就是动态规划的前奏，暴力递归！
主函数咋调用呢？求i=0–N-1上，j=0开始，装包，最后能得到的最大价值是多少？
直接调用：f(0,0)

手撕代码：

//复习：
    //**定义f(w,v,bag,i,j)：**
    //目前已经从0--i-1范围内装了j这么多（重量，体积都行）
    //现在从i--N-1范围内决定，要i，还是不要i的物品，能得到的最大价值是多少？
    public static int f(int[] w, int[] v, int bag, int i, int j){
        //在决定过程中：
        //（2）一旦发现你已经装了的总量j>bag了，书包装不下了，你这方案废了，返回-1，无效！
        if (j > bag) return -1;
        //（1）一旦发现你i=N了，越界，没有货物了，多增加的价值就是0，返回0
        if (i == w.length) return 0;

        //（3）如果还能装下：
        //——咱不要i这个物品，那直接去i+1位置决定就行，调用f(i **+1**,j)，j没变，因为你没要
        int value1 = f(w, v, bag, i + 1, j);
        //——咱要i这个物品，那调用f(i **+1**,j **+w[i]**)，j多了i的重量，下一次去i+1决定，
        // 但很可能这个返回值是-1，那就放弃，不是-1那就可以将v[i]累加f(i **+1**,j **+w[i]**)，作为增加的价值。

        int value2 = f(w, v, bag, i + 1, j + w[i]);
        if (value2 != -1) value2 += v[i];//把i拿走还能有效
        //最终上面这两种情况，谁得到的价值更大，要谁，返回。作为当前决定i之后得到的最大价值。

        return Math.max(value1, value2);
    }
    //调用
    public static int putBagReview(int[] w, int[] v, int bag){
        if (w == null || w.length == 0) return 0;

        return f(w, v, bag, 0, 0);
    }

    public static void test(){
        int[] w = {1,2,3};
        int[] v = {10,10,30};
        int bag = 3;//结果应该是30
        System.out.println(putBag1(w, v, bag));
        System.out.println(putBagReview(w, v, bag));
    }

结果：

30
30

2个变量，不带bag常量

上面老师带上bag：public static int f(int[] w, int[] v, int bag, int i, int j)
这样很麻烦的
干脆咱们想办法省掉bag
这么定义：

public static int f2(int[] w, int[] v, int i, int j)

j是目前书包还剩余的空间，最开始还剩下j=bag这么大的空间，请问我们从i=0–N-1上决定i要还是不要，能装最大多少值？

那就很方便了
（1）如果剩余空间压根没了j<0那无效呗，返回-1；
（2）如果i=N（1）越界，没有货物了，多增加的价值就是0，返回0
（3）如果还能装下：
——咱不要i这个物品，那直接去i+1位置决定就行，调用f(i +1,j)，j没变，因为你没要

——咱要i这个物品，那调用f(i +1,j -w[i])，j 减少 i的重量，下一次去i+1决定，但很可能这个返回值是-1，那就放弃，不是-1那就可以将v[i]累加f(i +1,j +w[i])，作为增加的价值。——这里是j减少重量哦！！！价值是增加的没动
最终上面这两种情况，谁得到的价值更大，要谁，返回。作为当前决定i之后得到的最大价值。

主函数咋调用呢？求i=0–N-1上，j=bag开始，装包，最后能得到的最大价值是多少？
直接调用：f(0,bag)
手撕代码：

//复习；**j是目前书包还剩余的空间**，最开始还剩下j=bag这么大的空间，
    // 请问我们从i=0--N-1上决定i要还是不要，能装最大多少值？
    public static int f2(int[] w, int[] v, int i, int j){
        //在决定过程中：
        //（2）一旦发现你已经装了的总量j<0了，书包装没空间了，你这方案废了，返回-1，无效！
        if (j < 0) return -1;
        //（1）一旦发现你i=N了，越界，没有货物了，多增加的价值就是0，返回0
        if (i == w.length) return 0;

        //（3）如果还能装下：
        //——咱不要i这个物品，那直接去i+1位置决定就行，调用f(i **+1**,j)，j没变，因为你没要
        int value1 = f2(w, v, i + 1, j);
        //——咱要i这个物品，那调用f2(i **+1**,j **-w[i]**)，j减少i的重量，下一次去i+1决定，
        // 但很可能这个返回值是-1，那就放弃，不是-1那就可以将v[i]累加f(i **+1**,j **+w[i]**)，作为增加的价值。

        int value2 = f2(w, v, i + 1, j - w[i]);
        if (value2 != -1) value2 += v[i];//把i拿走还能有效
        //最终上面这两种情况，谁得到的价值更大，要谁，返回。作为当前决定i之后得到的最大价值。

        return Math.max(value1, value2);
    }
    //调用
    public static int putBagReview2(int[] w, int[] v, int bag){
        if (w == null || w.length == 0) return 0;

        return f2(w, v, 0, bag);
    }

    public static void test(){
        int[] w = {1,2,3};
        int[] v = {10,10,30};
        int bag = 3;//结果应该是30
        System.out.println(putBag1(w, v, bag));
        System.out.println(putBagReview(w, v, bag));
        System.out.println(putBagReview2(w, v, bag));
    }

是不是很巧？

30
30
30

暴力递归代码改为动态规划填表

咱们根据：

public static int f2(int[] w, int[] v, int i, int j)

j是目前书包还剩余的空间，最开始还剩下j=bag这么大的空间，请问我们从i=0–N-1上决定i要还是不要，能装最大多少值？
来改动态规划的代码

2个变量i和j
一个做行，一个做列
咱们定义数组dp，为二维表格
其中 dp[i][j] 代表啥 ？ ** 还剩下j这么大的空间，请问我们从i–N-1上决定i要还是不要，能装最大多少值？**
显然：
i从0–N取值
j从bag–0取值
所以dp是一个N+1 * bag+1的二维表格

主函数调用f2(w, v, 0, bag);，则咱们最终要的结果就是dp[0][bag]，上图中五角星那个格子的值，就是咱本题要求的答案！

咱们现在根据f2函数来填dp表：
（1）如果剩余空间压根没了j<0那无效呗，返回-1；
这部分，表格压根就没有j<0的地方，不管
（2）如果i=N（1）越界，没有货物了，多增加的价值就是0，返回0
显然dp中最后一行，i=N那个行，全部是0
（3）如果还能装下：
宏观调度：

for (int i = N - 1; i >= 0; i--) {
     //从N-1行，一行一行回来填
     for (int j = 0; j <= bag; j++) {
     //从j=0列，一列一列往右填

中间填dp[i][j]:
——咱不要i这个物品，那直接去i+1位置决定就行，调用f(i +1,j)，j没变，因为你没要
即int value1 = dp[i + 1][j];
——咱要i这个物品，那调用f(i +1,j -w[i])，j 减少 i的重量，下一次去i+1决定，但很可能这个返回值是-1，那就放弃，不是-1那就可以将v[i]累加f(i +1,j +w[i])，作为增加的价值。——这里是j减少重量哦！！！价值是增加的没动
即：

int value2 = dp[i + 1][j - w[i]];
if (value2 != -1) value2 += v[i];//把i拿走还能有效

最终上面这两种情况，谁得到的价值更大，要谁，返回。作为当前决定i之后得到的最大价值。
根据前面暴力递归的代码：dp[i][j] =Math.max(value1, value2);

主函数咋调用呢？求i=0–N-1上，j=bag开始，装包，最后能得到的最大价值是多少？
返回dp[0][bag]

仔细阅读下面的代码，就是根据f2来的：

//复习；其中 dp[i][j] 代表啥 ？ ** 还剩下j这么大的空间，请问我们从i--N-1上决定i要还是不要，能装最大多少值？**
    public static int putBagReview2DP(int[] w, int[] v, int bag){
        if (w == null || w.length == 0) return 0;

        int N = w.length;
        int[][] dp = new int[N + 1][bag + 1];
        //在决定过程中：
        //（2）一旦发现你已经装了的总量j<0了，书包装没空间了，你这方案废了，返回-1，无效！——默认不管
        //（1）一旦发现你i=N了，越界，没有货物了，多增加的价值就是0，返回0——默认dp[N][j]就是0哦

        //（3）如果还能装下：
        for (int i = N - 1; i >= 0; i--) {
            //从i=N-1行，一行一行回来填
            for (int j = 0; j <= bag; j++) {
                //从j=0列，一列一列往右填
                //——咱不要i这个物品，那直接去i+1位置决定就行，调用f(i **+1**,j)，j没变，因为你没要
                int value1 = dp[i + 1][j];
                //——咱要i这个物品，那调用f2(i **+1**,j **-w[i]**)，j减少i的重量，下一次去i+1决定，
                // 但很可能这个返回值是-1，那就放弃，不是-1那就可以将v[i]累加f(i **+1**,j **+w[i]**)，作为增加的价值。

                int value2 = -1;
                if (j - w[i] >= 0) value2 = dp[i + 1][j - w[i]];
                if (value2 != -1) value2 += v[i];//把i拿走还能有效
                //最终上面这两种情况，谁得到的价值更大，要谁，返回。作为当前决定i之后得到的最大价值。
                dp[i][j] = Math.max(value1, value2);
            }
        }

        //主函数咋调用呢？求i=0--N-1上，j=bag开始，装包，最后能得到的最大价值是多少？
        return dp[0][bag];
    }

    public static void test(){
        int[] w = {1,2,3};
        int[] v = {10,10,30};
        int bag = 3;//结果应该是30
        System.out.println(putBag1(w, v, bag));
        System.out.println(putBagReview(w, v, bag));
        System.out.println(putBagReview2(w, v, bag));
        System.out.println(putBagReview2DP(w, v, bag));
    }

这就是暴力递归改为动态规划的代码，速度运行快很多，只需要o(N*bag)的时间复杂度填表即可，不必此次暴力递归求了

结果

30
30
30
30

---

总结

提示：重要经验：

1）DP1：从左往右的暴力递归尝试模型，探索i从0–N-1的情况
2）通过暴力递归，完全可以考虑转化为动态规划的代码，就是填表而已，有几个变量，就是填几维的表格。
3）笔试求AC，可以不考虑空间复杂度，但是面试既要考虑时间复杂度最优，也要考虑空间复杂度最优。