多重背包问题-二进制优化

多重背包问题

题目链接

ACWing 4.多重背包问题 I

题目描述

有 N 种物品和一个容量是 V的背包。

第 ii 种物品最多有 si 件，每件体积是 vi，价值是 wi。

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

输入格式

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

接下来有 N 行，每行三个整数 vi,wi,si用空格隔开，分别表示第 i种物品的体积、价值和数量。

输出格式

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

数据范围

0<N≤1000
0<V≤2000
0<vi,wi,si≤2000

提示：

本题考查多重背包的二进制优化方法。

输入样例

4 5
1 2 3
2 4 1
3 4 3
4 5 2

输出样例：

10

思路

这题与普通背包问题的区别在于，物品的个数不再是一个，也不是无限个。如何选取正确的个数，是这个题要解决的问题。

我们建立一个物品个数的数组nums，用于记录每种物品的个数。

在普通背包问题中，状态转移方程为

dp[i][j] = Math.max(dp[i - 1][j - volumns[i]] + values[i], dp[i - 1][j]或者dp[i][j] = dp[i- 1][j]

只考虑了一个物品的情况，而这里有nums[i]个物品，我们可以选取0 ~ nums[i]个物品，至于选哪个最后当时比较一下价值那个大就可以。

所以当我们选取k个物品时，状态转移方程为

dp[j][i] = Math.max(dp[j][i], dp[j - 1][i - k * volumn[j]] + k * value[j]或者dp[j][i] = dp[j - 1][i]

通过此转移方程可解决问题。

代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        int n = scn.nextInt();
        int capacity = scn.nextInt();
        int[] volumn = new int[n + 1];
        int[] value = new int[n + 1];
        int[] nums = new int[n + 1];
        int[][] dp = new int[n + 1][capacity + 1];
        for (int i = 1; i <= n; i++) {
            volumn[i] = scn.nextInt();
            value[i] = scn.nextInt();
            nums[i] = scn.nextInt();
        }
        for (int i = 1; i <= capacity; i++) {
            for (int j = 1; j <= n; j++) {
                dp[j][i] = dp[j - 1][i];
                for (int k = 1; k <= nums[j]; k++) {
                    if (i >= k * volumn[j]) {
                        dp[j][i] = Math.max(dp[j][i], dp[j - 1][i - k * volumn[j]] +  k * value[j]);
                    }
                }
            }
        }
        System.out.println(dp[n][capacity]);
    }
}

多重背包问题-----二进制优化

题目链接

ACWing 5.多重背包问题 II

问题

使用上述方法，我们用的时间复杂度为O(N * V * S)，一旦物品数量多了，程序运行时间就会很长。

所以我们需要使用二进制优化来减少时间复杂度。

思路

任何一个十进制数都可以拆分成多个二进制数表示。

例如: 888 => 2^0 + 2^1 + 2^2 + 2^3 + 2^4 + 2^5 + 2^6 + 2^7 + 2^8 + (888 - (2^0 + 2^1 + 2^2 + 2^3 + 2^4 + 2^5 + 2^6 + 2^7 + 2^8))

888拆分后的这些数，进行不重复的任意的排列组合可以组合成888以下的任何一个数。(1 ~ 888)

那我们把这些拆分后的当做一个物品，使用普通背包问题的方式进行计算，它能覆盖所有的情况，得到的结果会与循环888次得到的结果相同。

这样大大减少了计算量。就算物品的个数为Integer的最大值2147483647，也就是拆分成了32组而已，完美的解决了个数多的问题。

这种思路相当于把数量的问题变为了种类的问题，时间复杂度从O(N * V * S)变成了O(N * V )

代码

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 二进制拆分算法优化
        //将 数量为s的物品数量拆分成 2^0 + 2^1 + 2^2 + .... + s - (2 - (2^0 + 2^1 + 2^3 + ....))组
        // 这样拆分之后1 ~ s都能有这些拆分后的组组成，从而解决问题并优化
        Scanner scn = new Scanner(System.in);
        int n = scn.nextInt();
        int v = scn.nextInt();
        int[] values = new int[10000];
        int[] volumes = new int[10000];
        //用于记录拆分后物品的个数
        int size = 0;
        for (int k = 0; k < n; k++) {
            int volume = scn.nextInt();
            int value = scn.nextInt();
            int num = scn.nextInt();
            /*将一类物品按照二进制方式拆分成多个物品，然后就是普通背包问题了 */
            int i;
            for (i = 1; i < num; i <<= 1) {
                //由于从1开始，所以索引应该+1
                volumes[size + 1] = i * volume;
                values[size + 1] = i * value;
                size++;
                num -= i;
            }
            volumes[size + 1] = num * volume;
            values[size + 1] = num * value;
            size++;

        }
        int[][] dp = new int[size + 1][v + 1];
        for (int i = 1; i < size + 1; i++) {
            for (int j = 1; j < v + 1; j++) {
                if (volumes[i] <= j) {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - volumes[i]] + values[i]);
                } else {
                    dp[i][j] = dp[i- 1][j];
                }
            }
        }
        System.out.println(dp[size][v]);
        scn.close();
    }
}