完全背包问题优化推导过程

完全背包问题题目:
有 N 种物品和一个容量是 V 的背包，每种物品都有无限件可用。
第 i 种物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

完全背包问题在于物品都能无限可用,根据动态规划思想我们需要去寻找状态表示和状态转移方程

状态表示:
我们定义dp[i][j]表示使用前i个物品在不超过体积j的情况下总价值最大

状态转移方程:
根据01背包问题的思想,我们考虑有第i个物品和没有第i个物品的情况,则dp[i][j]就等于两种情况的最大值,又因为第i个物品是无限使用的则有第i个物品的情况下我们需要考虑i的个数k(kv[i]<=j)
dp[i][j] =Max(dp[i-1,j],dp[i-1][j-2v]+2w,f[i-1,j-3v]+3w…
推出 dp[i][j]=Math.(dp[i-1[j],dp[i-1][j=kv[i]]+w[i]

代码如下

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[] v = new int[n + 1];
        int[] w = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                for (int k = 0; k*v[i] <=j ; k++) {
                    dp[i][j]=Math.max(dp[i][j],dp[i-1][j-k*v[i]]+k*w[i]);
               } } }
        System.out.println(dp[n][m]);
    }}

我们求dp[i][j-v]的情况是
dp[i][j-v] =Max(dp[i-1,j-v],dp[i-1][j-2v]+w,f[i-1,j-3v]+2w…)
dp[i][j]的情况
dp[i][j] =Max(dp[i-1,j],dp[i-1][j-2v]+2w,f[i-1,j-3v]+3w…)
则推出dp[i][j]=Max(dp[i-1][j],dp[i][j-v[i]]+w[i])
代码变化为

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[] v = new int[n + 1];
        int[] w = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                dp[i][j] = dp[i - 1][j];
                if (j >= v[i]) {
                    dp[i][j] = Math.max(dp[i][j], dp[i][j - v[i] + w[i]]);
                } }
            System.out.println(dp[n][m]);
        } }}

此时我们发现我们只需要d[i]这一行的数据就可以从左向右推导

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int[] v = new int[n + 1];
        int[] w = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            v[i] = sc.nextInt();
            w[i] = sc.nextInt();
        }
        int[] dp = new int[m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = v[i]; j <= m; j++) {
                    dp[j] = Math.max(dp[j],dp[j - v[i] + w[i]]);
            }
            System.out.println(dp[m]);
        }
    }
}