ember/blog

Fork 0

ember 3a8af3d6ca 添加内容

2025-05-05 02:37:44 +08:00

14 KiB

Raw Blame History

title

description

date

slug

01背包

问题描述

有 n 个物品，第 k （$k=1,2,3,\cdots,n$）个物品有一个重量 weight(k) 和一个价值 value(k) 。现在有一个小偷，他有一个容量为 W 的背包，问小偷如何选择物品放入背包，使得背包中的总价值最大。

状态定义

我们假设小偷从第 k 个物品开始往前偷（为了方便，我们假设 k 从 1 开始而不是 0 ），当前的背包容量为 w ，此时能偷的最大价值为 dp(k,w) 。那么有两种情况：

如果 $w<weight\left( k \right) $，代表背包放不下第 k 个物品，此时 dp(k,w)=dp(k-1,w) 。
如果 $w\geqslant weight\left( k \right) $，代表背包可以放下第 k 个物品，此时：
- 可以偷这个物品：dp\left( k,w \right) =dp\left( k-1,w-weight\left( k \right) \right) +value\left( k \right)
- 也可以不偷：dp\left( k,w \right) =dp\left( k-1,w \right)
因此，dp\left( k,w \right) =max\left( 偷, 不偷 \right)

递归+记忆化搜索实现

我们可以用最直观的方式，用递归+记忆化搜索实现：

public class Solution {
    private static Integer[][] memo;
    // 用Integer数组而不用int数组，是因为int数组默认初始化为0，而Integer数组默认初始化为null

    public static int knapsack(int[] weight, int[] value, int W) {
        int n = weight.length;
        memo = new Integer[n + 1][W + 1];
        return dfs(weight, value, W, n);
    }

    private static int dfs(int[] weight, int[] value, int W, int k) {
        if (k == 0) return 0;
        if (memo[k][W] != null) return memo[k][W];
        if (W < weight[k - 1]) {
            memo[k][W] = dfs(weight, value, W, k - 1);
        } else {
            memo[k][W] = Math.max(dfs(weight, value, W, k - 1), dfs(weight, value, W - weight[k - 1], k - 1) + value[k - 1]);
        }
        return memo[k][W];
    }

    public static void main(String[] args) {
        int[] weight = {2, 3, 4, 5};
        int[] value = {3, 4, 5, 6};
        int W = 5;
        System.out.println(knapsack(weight, value, W));
    }
}

二维数组实现

public int knapsack(int[] weight, int[] value, int W) {
    int n = weight.length;
    int[][] dp = new int[n + 1][W + 1];
    // Java 默认初始化数组为 0

    // 注意，k对应前面假设中的1,2,...，对应weight和value数组中的k-1下标
    // 定义中weight(1)对应weight[0]，value(1)对应value[0]
    for (int k = 1; k <= n; k++) {
        for (int w = 1; w <= W; w++) {
            if (w < weight[k - 1]) {
                dp[k][w] = dp[k - 1][w];
            } else {
                dp[k][w] = Math.max(dp[k - 1][w], dp[k - 1][w - weight[k - 1]] + value[k - 1]);
            }
        }
    }

    return dp[n][W];
}

假设我们有5个物品，重量和价值分别如下：

k	重量	价值
1	2	1
2	3	2
3	4	3
4	5	2
5	6	4

我们可以看一下dp数组的每个值：

k\w	2	3	4	5	6	7
1	1	1	1	1	1	1
2	1	2	2	3	3	3
3	1	2	3	3	4	5
4	1	2	3	3	4	5
5	1	2	3	3	4	5

一维数组实现

一维数组实现主要是为了节省空间，并没有减少时间复杂度。我们把k消去，只留下w，这样一来，二维数组实现需要 O(nW) 的空间，而一维数组实现只需要 O(W) 的空间。

public int knapsack(int[] weight, int[] value, int W) {
    int n = weight.length;
    int[] dp = new int[W + 1];
    // Java 默认初始化数组为 0

    for (int k = 1; k <= n; k++) {  
        for (int w = W; w >= weight[k - 1]; w--) {
            // w >= weight[k - 1]：当背包可以放下第k个物品时才更新
            // 内层应该从后往前遍历，因为dp[w]依赖于dp[w - weight[k - 1]]，如果从前往后遍历，dp[w - weight[k - 1]]会被先更新，导致dp[w]的结果不正确
            // dp[w] (更新前) 相当于二维 DP 中的 dp[k-1][w] (不放物品 k 的情况)
            // dp[w - weights[k]] (更新前) 相当于二维 DP 中的 dp[k-1][w - weights[k]]
            dp[w] = Math.max(dp[w], dp[w - weight[k - 1]] + value[k - 1]);
        }
        // 经过内层 w 循环后，dp 数组已经更新，
        // 此时 dp[w] 存储的就是考虑前 k 个物品、容量为 w 的最大价值
    }

    // 或者可以简写成这样，方便记忆：
    for (int k = 0; k < n; k++) {
        for (int w = W; w >= weight[k]; w--) {
            dp[w] = Math.max(dp[w], dp[w - weight[k]] + value[k]);
        }
    }

    return dp[W];
}

完全背包

问题描述

有 n 个物品，第 k （$k=1,2,3,\cdots,n$）个物品有一个重量 weight(k) 和一个价值 value(k) 。现在有一个小偷，他有一个容量为 W 的背包，每个物品可以选择无数次放入背包，问小偷如何选择物品放入背包，使得背包中的总价值最大。

状态定义

这个问题和01背包问题很相似，区别在于每个物品可以选择无数次放入背包，即允许重复选择。因此，我们只需要更改“放”的逻辑，从“放一个”改为“放多个”。

如果 $w<weight\left( k \right) $，代表背包放不下第 k 个物品，此时 dp(k,w)=dp(k-1,w) 。
如果 $w\geqslant weight\left( k \right) $，代表背包可以放下第 k 个物品，此时：
- 可以偷这个物品：$dp\left( k,w \right) =dp\left( k,w-weight\left( k \right) \right) +value\left( k \right) $（唯一区别：dp的第一个参数使用k而不是k-1，表示当前物品k可以被重复选择）
- 也可以不偷：dp\left( k,w \right) =dp\left( k-1,w \right)
因此，dp\left( k,w \right) =max\left( 偷, 不偷 \right)

二维数组实现

public int knapsack(int[] weight, int[] value, int W) {
    int n = weight.length;
    int[][] dp = new int[n + 1][W + 1];
    // Java 默认初始化数组为 0

    for (int k = 1; k <= n; k++) {
        for (int w = 1; w <= W; w++) {
            if (w < weight[k - 1]) {
                dp[k][w] = dp[k - 1][w];
            } else {
                dp[k][w] = Math.max(dp[k - 1][w], dp[k][w - weight[k - 1]] + value[k - 1]);
            }
        }
    }

    return dp[n][W];
}

一维数组实现

一维数组消去了k，只保留w，这样一来，其核心运算代码与01背包的一维数组实现完全相同，唯一不同的是内层遍历顺序从后往前变成了从前往后，来确保每个物品可以被多次选择。

public int knapsack(int[] weight, int[] value, int W) {
    int n = weight.length;
    int[] dp = new int[W + 1];
    // Java 默认初始化数组为 0
    // 注意，k对应前面假设中的1,2,...，对应weight和value数组中的k-1下标
    // 定义中weight(1)对应weight[0]，value(1)对应value[0]
    for (int k = 1; k <= n; k++) {
        for (int w = weight[k - 1]; w <= W; w++) {
            dp[w] = Math.max(dp[w], dp[w - weight[k - 1]] + value[k - 1]);
        }
    }

    // 或者可以简写成这样，方便记忆：
    for (int k = 0; k < n; k++) {
        for (int w = weight[k]; w <= W; w++) {
            dp[w] = Math.max(dp[w], dp[w - weight[k]] + value[k]);
        }
    }

    return dp[W];
}

多重背包

问题描述

有 n 个物品，第 k （$k=1,2,3,\cdots,n$）个物品有一个重量 weight(k) 和一个价值 value(k) 。现在有一个小偷，他有一个容量为 W 的背包，每个物品放入背包的次数不超过$count(k)$，问小偷如何选择物品放入背包，使得背包中的总价值最大。

这个问题其实就是分组。最直观的方法是把每个相同的物品都直接看作一个独立的物品（暴力拆解），然后使用01背包的解法。

暴力拆解

public static int multipleBag(int[] weight, int[] value, int[] num, int W) {
    int n = weight.length;
    int[] dp = new int[W + 1];
    // Java 默认初始化数组为 0

    for (int k = 0; k < n; k++) {
        for (int c = 1; c <= num[k]; c++) { // 拆成 num[k] 件物品
            for (int w = W; w >= weight[k]; w--) {
                dp[w] = Math.max(dp[w], dp[w - weight[k]] + value[k]);
            }
        }
    }

    return dp[W];
}

这种暴力拆解的方法时间复杂度为 O(nW\sum_{i=1}^{n}num[i]) ，当数据量较大时，时间复杂度会非常高。

二进制拆解

二进制拆解的思路是将每个物品的个数拆成若干个2的幂次方，然后使用01背包的解法。依据一个事实：任何整数都可以表示成若干个2的幂次方之和，如13=1+4+8。

public static int multipleBag(int[] weight, int[] value, int[] num, int W) {
    int n = weight.length;
    int[] dp = new int[W + 1];
    // Java 默认初始化数组为 0

    for (int k = 0; k < n; k++) {
        int m = 1; // 用来生成1,2,4,8… 的“拆分基数”
        int c = num[k]; // 当前物品的个数
        while (c > 0) {
            int count = Math.min(c, m); // 取c和m中较小者，避免拆分过多
            int newWeight = weight[k] * count;
            int newValue = value[k] * count;
            // 标准01背包
            for (int w = W; w >= newWeight; w--) {
                dp[w] = Math.max(dp[w], dp[w - newWeight] + newValue);
            }
            c -= count; // 减去已经拆分出去的件数
            m <<= 1; // 下一轮基数翻倍：1→2→4→8…
        }
    }

    return dp[W];
}

这种方法把每个物品的个数拆成了若干个2的幂次方，时间复杂度为 O(nW\sum_{i=1}^{n}log(num[i])) ，大大降低了时间复杂度。

单调队列优化

单调队列优化的时间复杂度为 O(nW) ，比暴力拆解和二进制拆解都要快。


    /**
     * 多重背包——单调队列优化
     * @param weight 每种物品重量数组 w[i]
     * @param value  每种物品价值数组 v[i]
     * @param num    每种物品最大数量数组 c[i]
     * @param W       背包总容量
     * @return 背包能装下的最大价值
     */
    public static int multipleBag(int[] weight, int[] value, int[] num, int W) {
        int n = weight.length;
        // dp[j] 表示当前考虑完若干物品后，容量恰好为 j 时的最大价值
        int[] dp = new int[W + 1];

        // 枚举每一类物品
        for (int k = 0; k < n; k++) {
            int w = weight[k], v = value[k], c = num[k];

            // 对同一种物品，根据 j mod w 分成 w 条子序列
            for (int r = 0; r < w; r++) {
                // 维护一个双端队列，队列元素是索引 m，以及对应的 f(m) = dp_old[r + m*w] - m*v
                Deque<Integer> deque = new ArrayDeque<>();

                // m = 0,1,2,...；对应 j = r + m*w
                // 我们需要遍历这一条“序列”上的所有 j
                for (int j = r, m = 0; j <= W; j += w, m++) {
                    // 1) 计算当前点的 f(m)
                    int fm = dp[j] - m * v;

                    // 2) 将 fm 进队尾，保持队列单调递减（队头是最大）
                    while (!deque.isEmpty()) {
                        int mTail = deque.peekLast();
                        int fTail = dp[r + mTail * w] - mTail * v;
                        if (fTail <= fm) {
                            deque.pollLast();
                        } else {
                            break;
                        }
                    }
                    deque.offerLast(m);

                    // 3) 弹出过期元素（下标 < m - c）
                    if (deque.peekFirst() < m - c) {
                        deque.pollFirst();
                    }

                    // 4) 队头就是窗口 [m-c, m] 内最大的 f(u)
                    int bestM = deque.peekFirst();
                    int bestF = dp[r + bestM * w] - bestM * v;

                    // 5) 恢复成 dp_new[j]
                    dp[j] = bestF + m * v;
                }
            }
        }

        return dp[W];
    }

我们的总体思路是：

dp[j]：表示“当前已经处理完第 0…k 类物品后，恰好装满容量 j 的最大价值”。
对每一类物品 k，我们要用单调队列优化下面这个转移：


dp_{\text{new}}[j]
= \max_{0 \le t \le c_k,\; j - t w_k \ge 0}
    \bigl(dp_{\text{old}}[\,j - t w_k\,] + t\,v_k\bigr).

首先按 “模 w” 分组，

for (int r = 0; r < w; r++) {
    // 序列：j = r, r+w, r+2w, …
}

把所有容量 j 按 j % w == r 分成 w 条独立的序列，这样处理起来只需线性扫一遍。然后我们定义 f(m)，令


    m = \frac{j - r}{w},\quad
    j = r + m\,w;

定义


    f(m) = dp_{\text{old}}[r + m\,w] - m\,v_k.

那么转移就变成


    dp_{\text{new}}[r + m\,w]
    = \max_{m-c_k \le u \le m}\bigl(f(u)\bigr) + mv_k,

即在下标 u ∈ [m - c, m] 区间里取最大。

然后用单调队列维护窗口最大值。

队列存什么？ 存下标 u，真正的比较量是 dp[r + u*w] - u*v。
进队（保持递减）：

while (!deque.isEmpty() && f(tail) <= f(m)) deque.pollLast();
deque.offerLast(m);

这样队头永远是窗口内最大的 f(u)。

出队过期：

if (deque.peekFirst() < m - c) deque.pollFirst();

确保窗口大小不超过 c+1。

最后恢复 dp 新值，队头 bestM = deque.peekFirst()，对应最大 f(bestM)。


    dp[j] = f(\text{bestM}) + m\,v
        = \bigl(dp_{\text{old}}[r + bestM\,w] - bestM\,v\bigr) + m\,v.

这样优化后，时间复杂度为 O(nW) 。

14 KiB Raw Blame History Unescape Escape

01背包

问题描述

状态定义

递归+记忆化搜索实现

二维数组实现

一维数组实现

完全背包

问题描述

状态定义

二维数组实现

一维数组实现

多重背包

问题描述

暴力拆解

二进制拆解

单调队列优化

14 KiB

Raw Blame History