c/c++蓝桥杯经典编程题100道（21）背包问题

#include <stdio.h>
#include <string.h>

#define MAX_W 100
#define MAX_N 100

int max(int a, int b) { return a > b ? a : b; }

int knapsack01(int W, int wt[], int val[], int n) {
    int dp[MAX_N][MAX_W]; // dp[i][j]：前i个物品，容量j的最大价值
    memset(dp, 0, sizeof(dp));
    
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= W; j++) {
            if (wt[i-1] > j) { // 当前物品超重，无法选择
                dp[i][j] = dp[i-1][j];
            } else { // 能选：比较选或不选的价值
                dp[i][j] = max(dp[i-1][j], dp[i-1][j - wt[i-1]] + val[i-1]);
            }
        }
    }
    return dp[n][W];
}

int main() {
    int W = 4;
    int wt[] = {1,3,4}, val[] = {15,20,30};
    int n = sizeof(wt)/sizeof(wt[0]);
    printf("0-1背包最大价值：%d\n", knapsack01(W, wt, val, n)); // 输出35
    return 0;
}

代码逻辑：

初始化DP表 ：dp[i][j] 表示前 i 个物品在容量 j 下的最大价值。
填表规则：
- 物品超重时，继承上一行结果。
- 否则，取"不选"和"选"的最大值。

解法2：0-1背包（空间优化版，难度★★）

通俗解释：

仅用一维数组，倒序遍历容量，避免覆盖未计算的数据。

cs 复制代码

int knapsack01Optimized(int W, int wt[], int val[], int n) {
    int dp[MAX_W] = {0};
    for (int i = 0; i < n; i++) { // 遍历物品
        for (int j = W; j >= wt[i]; j--) { // 逆序更新，防止重复选
            dp[j] = max(dp[j], dp[j - wt[i]] + val[i]);
        }
    }
    return dp[W];
}

代码逻辑：

一维数组 ：dp[j] 表示容量 j 的最大价值。
逆序遍历：确保每个物品只被选一次。

解法3：完全背包（难度★★）

通俗解释：

正序遍历容量，允许重复选择物品，像存钱罐可以多次塞硬币。

cs 复制代码

int completeKnapsack(int W, int wt[], int val[], int n) {
    int dp[MAX_W] = {0};
    for (int i = 0; i < n; i++) {
        for (int j = wt[i]; j <= W; j++) { // 正序更新，允许重复选
            dp[j] = max(dp[j], dp[j - wt[i]] + val[i]);
        }
    }
    return dp[W];
}

int main() {
    int W = 5;
    int wt[] = {1,2}, val[] = {15,20};
    int n = sizeof(wt)/sizeof(wt[0]);
    printf("完全背包最大价值：%d\n", completeKnapsack(W, wt, val, n)); // 输出75
    return 0;
}

代码逻辑：

正序遍历：允许同一物品多次被选中。

四、C++实现

解法1：0-1背包（STL vector版，难度★☆）

通俗解释：

使用 vector 替代数组，动态管理内存，避免固定大小限制。

cpp

cpp 复制代码

#include <iostream>
#include <vector>
using namespace std;

int knapsack01STL(int W, vector<int>& wt, vector<int>& val) {
    vector<int> dp(W + 1, 0);
    for (int i = 0; i < wt.size(); i++) {
        for (int j = W; j >= wt[i]; j--) { // 逆序更新
            dp[j] = max(dp[j], dp[j - wt[i]] + val[i]);
        }
    }
    return dp[W];
}

int main() {
    vector<int> wt = {1,3,4}, val = {15,20,30};
    int W = 4;
    cout << "0-1背包最大价值：" << knapsack01STL(W, wt, val) << endl; // 输出35
    return 0;
}

代码逻辑：

与C语言空间优化版相同，但使用 vector 动态管理内存。

解法2：多重背包（二进制优化，难度★★★）

通俗解释：

将物品数量拆分为二进制组合（如7=1+2+4），转化为0-1背包问题。

cpp

cpp 复制代码

int multiKnapsack(int W, vector<int>& wt, vector<int>& val, vector<int>& cnt) {
    vector<int> dp(W + 1, 0);
    for (int i = 0; i < wt.size(); i++) {
        int k = 1;
        int remain = cnt[i];
        while (k <= remain) { // 二进制拆分
            int w = wt[i] * k;
            int v = val[i] * k;
            for (int j = W; j >= w; j--) {
                dp[j] = max(dp[j], dp[j - w] + v);
            }
            remain -= k;
            k *= 2;
        }
        if (remain > 0) { // 处理剩余数量
            int w = wt[i] * remain;
            int v = val[i] * remain;
            for (int j = W; j >= w; j--) {
                dp[j] = max(dp[j], dp[j - w] + v);
            }
        }
    }
    return dp[W];
}

int main() {
    vector<int> wt = {2,3}, val = {5,7}, cnt = {2,3};
    int W = 10;
    cout << "多重背包最大价值：" << multiKnapsack(W, wt, val, cnt) << endl; // 输出24
    return 0;
}

代码逻辑：

二进制拆分：将数量拆分为2的幂次之和，减少物品数量。
转化为0-1背包：对每个拆分后的物品进行0-1背包处理。

五、总结对比表

方法	时间复杂度	空间复杂度	优点	缺点
0-1背包基础DP	O(nW)	O(nW)	直观易理解	内存占用高
0-1背包空间优化	O(nW)	O(W)	内存高效	无法回溯具体方案
完全背包	O(nW)	O(W)	支持无限次选择	不适用0-1场景
多重背包优化	O(nW logS)	O(W)	处理数量限制	实现较复杂

六、特殊方法与内置函数补充

1. C++ STL的 `max` 函数

用法：max(a, b) 返回较大值，需包含 <algorithm> 头文件。

2. 滚动数组优化

原理：利用奇偶行交替存储，将二维DP压缩为两个一维数组。

3. 单调队列优化

适用场景：多重背包的进一步优化，时间复杂度降至O(nW)。

->返回c/c++蓝桥杯经典编程题100道-目录