动态规划——背包问题

01背包

每种物品只允许使用一次，求背包的最大价值。https://www.acwing.com/problem/content/2/
纵向：物品种类
横向：背包体积
对比上一层这个位置的价值（f[i - 1][j]）与这个位置向左移动 v 体积加上这一层这个物品的总价值（f[i - 1][j - v] + w ）大小。

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int N = in.nextInt(), V = in.nextInt();
        
        int[][] f = new int[1010][1010];
        
        for(int i = 1; i <= N; i++){
            int v = in.nextInt(), w = in.nextInt();
            for(int j = 1; j <= V; j++){
                f[i][j] = f[i - 1][j];
                if(j >= v) f[i][j] = Math.max(f[i][j], f[i - 1][j - v] + w);
            }
        }
        
        int res = 0;
        for(int j = 0; j <= V; j++) res = Math.max(res, f[N][j]);
        System.out.println(res);
    }
}

完全背包

物品无限使用，求背包的最大价值。https://www.acwing.com/problem/content/description/3/
纵向：物品种类
横向：背包体积

因为是从左向右遍历，所以左边小体积背包的最大值已经求出。
对比当前位置的上一层c价值与当前位置向左移动v的位置的价值（f[i][j - v]）加上当前物品价值w 的大小

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int N = in.nextInt(), V = in.nextInt();
        int[][] f = new int[1010][1010];
        
        for(int i = 1; i <= N; i++){
            int v = in.nextInt(), w = in.nextInt();
            for(int j = 0; j <= V; j++){
                f[i][j] = f[i - 1][j];
                if(j >= v) f[i][j] = Math.max(f[i - 1][j], f[i][j - v] + w);
            }
        }
        
        int res = 0;
        for(int j = 0; j <= V; j++) res = Math.max(res, f[N][j]);
        System.out.println(res);
    }
}

简化： 因为许多题背包容量大或物品种类多，容易造成二维数组内存溢出。简化成一维。

因为只会用到这个位置上一层 （f[i - 1][j]），和这个位置的左边数据。所以完全可以用一层来覆盖上一层无用数据，这是完全等价的。

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int N = in.nextInt(), V = in.nextInt();
        int[] f = new int[1010];
        
        for(int i = 1; i <= N; i++){
            int v = in.nextInt(), w = in.nextInt();
            for(int j = 0; j <= V; j++){
                if(j >= v) f[j] = Math.max(f[j], f[j - v] + w);
            }
        }
        
        int res = 0;
        for(int j = 0; j <= V; j++) res = Math.max(res, f[j]);
        System.out.println(res);
    }
}

多重背包

物品有限使用，求背包的最大价值。https://www.acwing.com/problem/content/description/4/
纵向：物品种类
横向：背包体积

和01背包相似，不过他能使用多次，所以要加一层循环判断。（注意边界）

for(int k = 0; k <= s && k * v <= j; k++) f[i][j] = Math.max(f[i][j], f[i - 1][j - v * k] + w * k);

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int N = in.nextInt(), V = in.nextInt();
        int[][] f = new int[1010][1010];
        
        for(int i = 1; i <= N; i++){
            int v = in.nextInt(), w = in.nextInt(), s = in.nextInt();
            for(int j = 0; j <= V; j++){
                f[i][j] = f[i - 1][j];
                for(int k = 0; k <= s && k * v <= j; k++) 
                    f[i][j] = Math.max(f[i][j], f[i - 1][j - v * k] + w * k);
            }
        }
        int res = 0;
        for(int j = 0; j <= V; j++) res = Math.max(res, f[N][j]);
        System.out.println(res);
    }
}

满背包求组合个数

• 不考虑排序 力扣518：零钱兑换

先遍历物品、在遍历体积

class Solution {
    public int change(int amount, int[] coins) {
        int[] dp = new int[amount + 1]; // dp[x]表示组成金额为x的种类的个数（dp[x]）
        dp[0] = 1;
        
        for(int coin : coins){ // 遍历物品
            for(int j = coin; j <= amount; j++){ // 遍历背包容量，装满背包的种类个数
                dp[j] += dp[j - coin];
            }
        }
        return dp[amount];
    }
}

• 考虑排序 力扣377：组数总和4

先遍历体积，在遍历物品

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int[] dp = new int[target + 1];
        dp[0] = 1;

        // 装满背包不同种类的个数（带排序）
        
        for(int j = 0; j <= target; j++){ // 背包大小
            for(int num : nums){ // 物品
                if(j < num) continue;
                dp[j] += dp[j - num];
            }
        }
        return dp[target];
    }
}