动态规划-完全背包模板题

完全背包（NowCoder DP42）

题目描述：


状态表示：
根据题目要求以及经验对于第一问和第二问分别设置二维数组f和g，使用f[i][j]表示给定前i个物品供选择，选择的物品总空间不超过j时的物品最大总价值，使用g[i][j]表示给定前i个物品供选择，选择的物品总空间满足j时的物品最大总价值。
状态转移方程：
对于第一问的状态转移方程，也是和前面的01背包问题很类似，对于f[i][j]就是分析对于第i个元素是否选择，不选第i个元素时，f[i][j]=f[i-1][j]，因为这里是完全背包问题，所以对于每一个元素可以选择多次，因此选择第i个元素可以分为多种情况，你可以只选择一个i元素也可以选择多个i位置元素，当然选择i元素时要满足条件就是j-k* volume[i]>=0（k是选择i位置元素的次数）。当选择一次i位置元素时，满足条件时f[i][j]=f[i-1][j-volume[i]]+value[i]，当选择两次i位置元素时，满足判断条件时f[i][j]=f[i-1][j-2* volume[i]]+2* value[i]…所以最终f[i][j]=max(dp[i-1][j],f[i-1][j-volume[i]]+value[i],f[i-1][j-2* volume[i]]+2* value[i],…)。这个过程可以通过循环处理，但是没有必要因为使用数学的方法可以完全的去表示后面选取多次i位置元素的不同情况，f[i][j-volume[i]]+value[i]=max(f[i-1][j-volume[i]]+value[i],f[i-1][j-2* volume[i]]+2* value[i],…),此时f[i][j]=max(f[i-1][j],f[i][j-volume[i]]+value[i]).
对于第二问和第一问状态转移方程基本上是一致的，但是它这里多了一种情况，就是拥有的物品的体积无法恰好装满背包的空间，我们将这种情况下的g[i][j]赋为-1，要想完成最后的g[i][j]=max(g[i-1][j],g[i][j-volume[i]]+value[i])计算，除了要满足j-volume[i]大于等于0还必须要满足g[i][j-volume[i]]不等于-1的条件。
初始化：
我们对于f和g也是和之前的问题一样，为了方便运算以及防止越界给这两个数组分别加上第0行和第0列。在数组f的第0行代表没有物品，那么此时无论背包空间多少价值都是0，所以将其第0行全赋为0即可，至于第0列无需初始化直接加入运算，原因在动态规划的上一篇01背包问题的博客有解释。在数组g的第0行，此时无物品，对于背包空间为1，2…等多种情况都无法满足，那么按照我们前面的要求就全赋为-1，对于数组g的第0列也是一样无需初始化直接加入运算即可。
填表顺序：
从上到下，从左至右。
返回值：
因为数组f和g两个数组都是物品个数n加1乘以背包空间大小加一，所以根据状态表示返回值应该就是f[n][v]和g[n][v]，当然这里不需要返回这两个值，只需要打印出来即可。
代码如下：

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            int v = in.nextInt();

            int[] value = new int[n];
            int[] volume = new int[n];
            for (int i = 0; i < n; i++) {
                int num1 = in.nextInt();
                int num2 = in.nextInt();
                volume[i] = num1;
                value[i] = num2;
            }

            int[][] f = new int[n + 1][v + 1];
            int[][] g = new int[n + 1][v + 1];

            for (int i = 1; i <= v; i++) {
                g[0][i] = -1;
            }

            for (int i = 1; i <= n; i++) {

                for (int j = 0; j <= v; j++) {

                    f[i][j] = f[i - 1][j];
                    if (j >= volume[i - 1]) {
                        f[i][j] = Math.max(f[i][j], f[i][j - volume[i - 1]] + value[i - 1]);
                    }

                    g[i][j] = g[i - 1][j];
                    if (j >= volume[i - 1] && g[i][j - volume[i - 1]] != -1) {
                        g[i][j] = Math.max(g[i][j], g[i][j - volume[i - 1]] + value[i - 1]);
                    }

                }
            }
            System.out.println(f[n][v]);
            System.out.println(g[n][v] == -1 ? 0 : g[n][v]);
        }
    }
}

优化后代码如下：

import java.util.Scanner;

// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextInt()) { // 注意 while 处理多个 case
            int n = in.nextInt();
            int v = in.nextInt();

            int[] value = new int[n];
            int[] volume = new int[n];
            for (int i = 0; i < n; i++) {
                int num1 = in.nextInt();
                int num2 = in.nextInt();
                volume[i] = num1;
                value[i] = num2;
            }

            int[] f = new int[v + 1];
            int[] g = new int[v + 1];

            for (int i = 1; i <= v; i++) {
                g[i] = -1;
            }

            for (int i = 1; i <= n; i++) {

                for (int j = volume[i - 1]; j <= v; j++) {

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

                    g[j] = g[j];
                    if (g[j - volume[i - 1]] != -1) {
                        g[j] = Math.max(g[j], g[j - volume[i - 1]] + value[i - 1]);
                    }

                }
            }
            System.out.println(f[v]);
            System.out.println(g[v] == -1 ? 0 : g[v]);
        }
    }
}

这里优化的填表顺序不同于01背包的从右至左，完全背包优化后代码填表顺序是从左至右。

题目链接
时间复杂度:O(N^2)
空间复杂度:O(N^2)
优化后空间复杂度:O(N)