【算法】【动态规划】【背包九讲】Knapsack Problem

dreambyday

已于 2022-09-24 21:28:31 修改

阅读量735

点赞数

CC 4.0 BY-SA版权

分类专栏： # 数据结构与算法文章标签：背包问题动态规划

于 2017-08-31 11:36:13 首次发布

本文链接：https://blog.youkuaiyun.com/dreambyday/article/details/77744259

数据结构与算法专栏收录该内容

17 篇文章

订阅专栏

本文详细解析了01背包、完全背包及多重背包问题的算法实现，包括朴素二维数组、一维优化、时间优化等方法，并提供了Java代码示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本文章用 AcWing 题目举例

一、01背包

题目：01背包问题

设 $dp_{i,j}$ 代表 i 件物品 j 容量背包可装的最大价值。

则其可以由两种结果递推得到

第i件物品不装到背包里,前i-1件物品用了j容量的包。 $d p [i + 1] [j] = d p [i] [j]$
第i件物品装到背包里，前i-1件物品用了 $j-w_{i}$ 容量的包。 $d p [i + 1] [j] = d p [i] [j - v [i + 1]] + w [i + 1]$

取两种递推结果的最大值即可。

1.1 朴素二维数组

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

1.2 一维优化

二维转一维的方法是画出二维表格图，看在一维滚动的情况下，如何使用旧数据。

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

二、完全背包

题目：完全背包问题

第i件物品可以选0次、1次、2次……，递推时判断所有选法的最大值

2.1 暴力推导

可以直观地得到公式：

$d p [i + 1] [j] = M a t h . ma x (d p [i] [j - v * k] + w * k, d p [i + 1] [j])$

时间复杂度为 $O (n v s)$


import java.util.Scanner;

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

2.2 时间优化

第i件物品取0次、1次、2次……
$d p [i + 1] [j] = M a t h . ma x (d p [i] [j - v [i + 1] * k] + w [i + 1] * k), k = 0, 1, 2, 3...$
可以转化为：第i件物品取0次和至少取1次
$d p [i + 1] [j] = M a t h . ma x (d p [i] [j], d p [i + 1] [j - v [i + 1]] + w [i + 1])$

import java.util.Scanner;

/**
 * 完全背包
 */
public class KnapsackFull {
    /**
     * dp[i][j] = dp[i-1][j],dp[i][j]+w[i],...
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();
            int total = scanner.nextInt();
            int[][] dp = new int[n+1][total+1];
            for (int i = 0; i < n; i++) {
                int v = scanner.nextInt();
                int w = scanner.nextInt();
                for (int j = 0; j <= total; j++) {
                    if (j >= v) {
                        dp[i+1][j] = Math.max(dp[i+1][j-v] + w,dp[i][j]);
                    } else {
                        dp[i+1][j] = dp[i][j];
                    }
                }
            }
            System.out.println(dp[n][total]);
        }
    }
}

2.3 一维优化


/**
 * 完全背包
 */
public class KnapsackFull {
    /**
     * dp[i][j] = dp[i-1][j],dp[i][j]+w[i],...
     */
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();
            int total = scanner.nextInt();
            int[] dp = new int[total+1];
            for (int i = 0; i < n; i++) {
                int v = scanner.nextInt();
                int w = scanner.nextInt();
                for (int j = 0; j <= total; j++) {
                    if (j >= v) {
                        dp[j] = Math.max(dp[j-v] + w,dp[j]);
                    } else {
                        dp[j] = dp[j];
                    }
                }
            }
            System.out.println(dp[total]);
        }
    }
}

三、多重背包

题目：多重背包问题 I

多重背包是有限制的完全背包。

3.1 暴力求解

可以在2.1节上稍加修改，增加限制


import java.util.Scanner;

/**
 * 多重背包
 */
public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextInt()) {
            int n = scanner.nextInt();
            int total = scanner.nextInt();
            int[][] dp = new int[n+1][total+1];
            for (int i = 0; i < n; i++) {
                int v = scanner.nextInt();
                int w = scanner.nextInt();
                int s = scanner.nextInt();
                for (int j = 0; j <= total; j++) {
                    for (int k = 0; k <= s && k * v <= j; k++) {
                        dp[i+1][j] = Math.max(dp[i][j-v*k] + w* k,dp[i+1][j]);
                    }
                }
            }
            System.out.println(dp[n][total]);
        }
    }
}