本文已参与「新人创作礼」活动，一起开启掘金创作之路。

往期

1. 01背包问题

题目

完全背包问题

有 $N$ 种物品和一个容量是 $V$ 的背包，每种物品都有无限件可用。

第 $i$ 种物品的体积是 $v_{i}$，价值是 $w_{i}$。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。

输入格式

第一行两个整数，$N$，$V$，用空格隔开，分别表示物品种数和背包容积。

接下来有 $N$ 行，每行两个整数 $v_{i}$,$w_{i}$，用空格隔开，分别表示第 $i$ 种物品的体积和价值。

输出格式

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

数据范围

$0< N,V\le 1000$

$0< v_{i} ,w_{i} \le 1000$

输入样例

4 5
1 2
2 4
3 4
4 5

输出样例

10

解题思路

完全背包问题的特点是：每个物品可以无限使用。

对于当前物品，与它相关的策略已并非取或不取两种，而是考虑取$0$件、取$1$件、取$2$件...取$k$件，直到超过当前背包容量$j$，即$k\ast v[i]\le j$。因此可以再添加一层循环，来遍历当前这个物品到底装多少个。

1. 状态定义 题目的变化对于状态的定义并没有任何影响，$dp[i][j]$仍然表示，前$i$个物品，在容量为$j$的背包下，最大的价值。

2. 状态转移

$dp[i][j]=max\left ( dp[i][j], dp[i-1][j-k\ast v[i]]+k\ast w[i]\right ) \left ( 0\le k \le \left \lfloor \frac{j}{v[i]} \right \rfloor \right )$

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

public class Main {
                            
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        int n = cin.nextInt();                 // 物品数量
        int c = cin.nextInt();                 // 背包容积
        int[] v = new int[n+1];                  // 物品的体积
        int[] w = new int[n+1];                  // 物品的价值
        for (int i = 1; i <= n; i++) {
            v[i] = cin.nextInt();
            w[i] = cin.nextInt();
        }
        
        int[][] dp = new int[n+1][c+1];
        
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= c; 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][c]);
    }
}

空间优化

列举一下更新次序的内部关系：

$dp[i][j]=max\left ( dp[i-1][j],dp[i-1][j-v]+w,dp[i-1][j-2v]+2w,... \right )$

$dp[i][j-v]=max\left ( dp[i-1][j-v],dp[i-1][j-2v]+w,dp[i-1][j-3v]+2w,... \right )$

由以上两式可得如下递推关系：

$dp[i][j]=max\left ( dp[i-1][j],dp[i][j-v[i]]+w[i] \right )$

因此，可以抛弃$k$循环。

import java.io.*;
import java.util.*;
public class Main {                            
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        int n = cin.nextInt();                 // 物品数量
        int c = cin.nextInt();                 // 背包容积
        int[] v = new int[n+1];                  // 物品的体积
        int[] w = new int[n+1];                  // 物品的价值
        for (int i = 1; i <= n; i++) {
            v[i] = cin.nextInt();
            w[i] = cin.nextInt();
        }        
        int[][] dp = new int[n+1][c+1];        
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j <= c; 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][c]);
    }
}

更近一步，对比01背包问题的状态转移方程：

• 二维 $dp[i][j]=max\left ( dp[i-1][j],dp[i-1][j-v[i]]+w[i] \right )$

• 一维 $dp[j]=max\left ( dp[j],dp[j-v[i]]+w[i] \right ) \left ( j降序 \right )$

可类比01背包问题的空间优化得到完全背包问题的一维状态转移方程：

$dp[j]=max\left ( dp[j],dp[j-v[i]]+w[i] \right ) \left ( j升序 \right )$

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

public class Main {
                            
    public static void main(String args[]) throws Exception {
        Scanner cin=new Scanner(System.in);
        int n = cin.nextInt();                 // 物品数量
        int c = cin.nextInt();                 // 背包容积
        int[] v = new int[n+1];                  // 物品的体积
        int[] w = new int[n+1];                  // 物品的价值
        for (int i = 1; i <= n; i++) {
            v[i] = cin.nextInt();
            w[i] = cin.nextInt();
        }
        
        int[] dp = new int[c+1];
        
        for (int i = 1; i <= n; i++) {
            for (int j = v[i]; j <= c; j++) {  // 注意和01背包的区别
                dp[j] = Math.max(dp[j], dp[j-v[i]]+w[i]); 
            }
        }
        
        System.out.println(dp[c]);
    }
}

Reference

1. 背包问题九讲
2. 完全背包问题