动态规划——01背包和完全背包

目录

01背包模型

题目 

dp 

 滚动数组优化

第一问 

第二问 

扩展

完全背包

题目 

动态规划​编辑 

滚动数组优化

 关于-1的代码层面优化

💰🪙

---

背包就是有限制条件的组合问题

01背包模型

题目 

有一个背包能容纳的体积是v，现在有n个物品，第i个物品的体积为vi，价值为wi。
(1)求这个背包至多能装多大价值的物品?
(2) 若背包恰好装满，求至多能装多大价值的物品?
输入描述:
第一行两个整数n和V，表示物品个数和背包体积接下来n行，每行两个数;vi，wi表示第i个物品的体积和价值
1 < n,V,vi,wi < 1000

dp[i][j] 表示从前i个位置选，总体积不超过 j /等于j ，所有选择中，最大的价值。

dp 

import java.util.Scanner;

public class KnapsackProblem {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n, V;
        // 物品个数
        n = scanner.nextInt();
        // 背包体积
        V = scanner.nextInt();

        int[] vi = new int[n];
        int[] wi = new int[n];

        for (int i = 0; i < n; i++) {
            // 第 i 个物品的体积
            vi[i] = scanner.nextInt();
            // 第 i 个物品的价值
            wi[i] = scanner.nextInt();
        }

        int maxValue1 = maxValue(vi, wi, V);
        int maxValue2 = maxValueFilled(vi, wi, V);

        System.out.println("问题 1：背包至多能装价值为 " + maxValue1 + " 的物品");
        System.out.println("问题 2：背包恰好装满时，能装价值为 " + maxValue2 + " 的物品");
    }

    public static int maxValue(int[] vi, int[] wi, int V) {
        int n = vi.length;
        int[][] dp = new int[n + 1][V + 1];

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= V; j++) {
                if (vi[i - 1] <= j) {
                    // 选择放入当前物品和不放入当前物品之间的较大值
                    dp[i][j] = Math.max(dp[i - 1][j], wi[i - 1] + dp[i - 1][j - vi[i - 1]]);
                } else {
                    // 如果当前物品的体积大于背包的剩余容量，则无法放入当前物品，继承之前的最优解
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        return dp[n][V];
    }

    public static int maxValueFilled(int[] vi, int[] wi, int V) {
        int n = vi.length;
        int[][] dp = new int[n + 1][V + 1];

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= V; j++) {
                if (vi[i - 1] <= j) {
                    // 选择放入当前物品和不放入当前物品之间的较大值
                    dp[i][j] = Math.max(dp[i - 1][j], wi[i - 1] + dp[i - 1][j - vi[i - 1]]);
                } else {
                    // 如果当前物品的体积大于背包的剩余容量，则无法放入当前物品，继承之前的最优解
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // 检查最后一行是否存在等于背包容量的最优解
        for (int j = V; j >= 0; j--) {
            if (dp[n][j] == dp[n][j]) {
                return dp[n][j];
            }
        }

        return 0;
    }
}

 滚动数组优化

普通的就用两个数组，1推2,1做3；

这里使用一个数组，从右往左计算覆盖。修改j的遍历顺序，去掉所有i

第一问 

//✅滚动数组
import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int v=in.nextInt();
        int n=in.nextInt();
        int[] vi=new int[n+1];
        int[] wi=new int[n+1];
        for(int i=1;i<=n;i++){
            vi[i]=in.nextInt();