背包九讲（附Cpp代码）

文档链接：

http://love-oriented.com/pack/pack2alpha1.pdf

1. 01背包

1）题目：

有n件物品和一个容量为v的背包。
第i件物品的费用是c[i]，价值是w[i]。
求解将哪些物品装入背包可使价值总和最大

2）输入：

测试用例数 
物品数 背包大小 
n个物品的ci和wi

3）代码：

#include <iostream>  
#include <cstring>  
#include <algorithm>  
using namespace std;  
#define maxV 1000  
  
int main(void) {  
    int times, n, v, ci, wi;  
    int f[maxV];  
    freopen("1.txt", "r", stdin);  
    cin >> times;  
    while (times--) {  
        memset(f, 0, sizeof(f));  
        cin >> n >> v;  
        for (int i = 0; i < n; i++) {  
            cin >> ci >> wi;  
            for (int j = v; j >= 0; j--) {  
                if (j >= ci)  
                    f[j] = max(f[j - ci] + wi, f[j]);  
            }  
        }  
        for (int i = 0; i <= v; i++) cout << f[i] << " ";  
        cout << endl;  
        cout << f[v] << endl;  
    }  
} 

4）测试文件：

2  
4 10  
2 4  
3 5  
4 6  
5 10  
  
5 20  
3 2  
7 3  
10 5  
15 6  
16 10 

2. 完全背包

1）题目：

有n件物品和一个容量为v的背包，每种物品都有无限件可用。
第i种物品的费用是c[i]，价值是w[i]。
求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

2）输入：

测试用例数 
物品数 背包容量
n个物品的ci和vi

3）代码：

#include <iostream>  
#include <cstring>  
#include <algorithm>  
  
using namespace std;  
#define maxV 1000  
  
int main(void) {  
    int cases, n, v, ci, wi;  
    int f[maxV];  
    freopen("2.txt", "r", stdin);  
    cin >> cases;  
    while (cases--) {  
        memset(f, 0, sizeof(f));  
        cin >> n >> v;  
        for (int i = 0; i < n; i++) {  
            cin >> ci >> wi;  
            for (int j = 0; j <= v; j++) {  
                if (j >= ci)  
                    f[j] = max(f[j], f[j - ci] + wi);  
            }  
        }  
        cout << f[v] << endl;  
    }  
}  

4）测试文件：

[plain]  view plain  copy

1. 2  
2. 4 10  
3. 2 4  
4. 3 5  
5. 4 6  
6. 5 10  
7.   
8. 5 20  
9. 3 2  
10. 7 3  
11. 10 5  
12. 15 6  
13. 16 10  

3. 多重背包

1）题目：

有n种物品和一个容量为v的背包。
第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。
求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

2）输入：

测试用例数 
物品数 背包容量
n个物品的ni ci wi

3）代码：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <algorithm>  
3. using namespace std;  
4. #define maxV 1000  
5.   
6. int f[maxV], v;  
7.   
8. void ZeroOnePack(int ci, int wi) {  
9.     for (int j = v; j >= 0; j--)   
10.         if (j >= ci)  
11.             f[j] = max(f[j], f[j - ci] + wi);  
12. }  
13.   
14. void CompletePack(int ci, int wi) {  
15.     for (int j = 0; j <= v; j++)   
16.         if (j >= ci)  
17.             f[j] = max(f[j], f[j - ci] + wi);  
18. }  
19.   
20. void MultiplePack(int ni, int ci, int wi) {  
21.     if (ni * ci >= v) {  
22.         CompletePack(ci, wi);  
23.         return;  
24.     }  
25.     int k = 1, amount = ni;  
26.     while (k < ni) {  
27.         ZeroOnePack(ci * k, wi * k);  
28.         amount -= k;  
29.         k *= 2;  
30.     }  
31.     ZeroOnePack(ci * amount, wi * amount);  
32. }  
33.   
34. int main(void) {  
35.     int cases, n, ni, ci, wi;  
36.     freopen("3.txt", "r", stdin);  
37.     cin >> cases;  
38.     while (cases--) {  
39.         memset(f, 0, sizeof(f));  
40.         cin >> n >> v;  
41.         for (int i = 0; i < n; i++) {  
42.             cin >> ni >> ci >> wi;  
43.             MultiplePack(ni, ci, wi);  
44.         }  
45.         //for (int i = 0; i <= v; i++) cout << f[i] << " "; cout << endl;  
46.         cout << f[v] << endl;  
47.     }  
48. }  

4）测试文件：

[plain]  view plain  copy

1. 2   
2. 3 10  
3. 1 1 10  
4. 2 2 4  
5. 3 3 11  
6.   
7. 4 20  
8. 5 2 5  
9. 2 3 6  
10. 3 4 8  
11. 1 6 19  

4. 混合三种背包

1）问题：

有的物品只可以取一次（01背包），有的物品可以取无限次（完全背包），有的物品可以取的次数有一个上限（多重背包）。
应该怎么求解呢？

2）输入：

测试用例数
物品数 背包容量
第i种物品的ni(无限次的标为-1) ci wi

3）代码：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <cstring>  
3. using namespace std;  
4. #define maxV 1000  
5.   
6. int f[maxV], v;  
7.   
8. void ZeroOnePack(int ci, int wi) {  
9.     for (int j = v; j >= 0; j--)   
10.         if (j >= ci)  
11.             f[j] = max(f[j], f[j - ci] + wi);  
12. }  
13.   
14. void CompletePack(int ci, int wi) {  
15.     for (int j = 0; j <= v; j++)   
16.         if (j >= ci)  
17.             f[j] = max(f[j], f[j - ci] + wi);  
18. }  
19.   
20. void MultiplePack(int ni, int ci, int wi) {  
21.     if (ni * ci >= v) {  
22.         CompletePack(ci, wi);  
23.         return;  
24.     }  
25.     int k = 1, amount = ni;  
26.     while (k < ni) {  
27.         ZeroOnePack(ci * k, wi * k);  
28.         amount -= k;  
29.         k *= 2;  
30.     }  
31.     ZeroOnePack(ci * amount, wi * amount);  
32. }  
33.   
34. int main(void) {  
35.     int cases, n, ni, ci, wi;  
36.     freopen("4.txt", "r", stdin);  
37.     cin >> cases;  
38.     while (cases--) {  
39.         memset(f, 0, sizeof(f));  
40.         cin >> n >> v;  
41.         for (int i = 0; i < n; i++) {  
42.             cin >> ni >> ci >> wi;  
43.             if (ni == 1) ZeroOnePack(ci, wi);  
44.             else if (ni == -1) CompletePack(ci, wi);  
45.             else MultiplePack(ni, ci, wi);  
46.         }  
47.         for (int i = 0; i <= v; i++) cout << f[i] << " "; cout << endl;  
48.         cout << f[v] << endl;  
49.     }  
50. }  

4）测试文件：

[plain]  view plain  copy

1. 2  
2. 3 10  
3. -1 1 2  
4. 2 2 5  
5. 1 3 7  
6.   
7. 4 20  
8. 3 2 5  
9. 4 4 6  
10. -1 6 8  
11. 1 7 10  

5. 二维费用的背包

1）问题：

对于每件物品，具有两种不同的费用；
选择这件物品必须同时付出这两种代价；
对于每种代价都有一个可付出的最大值（背包容量）。
问怎样选择物品可以得到最大的价值。
第i件物品所需的两种代价分别为a[i]和b[i]。
两种代价可付出的最大值（两种背包容量）分别为V和U。物品的价值为w[i]。

2）输入：

测试用例数
物品数 第一个背包容量v 第二个背包容量u
第i个物品的ai bi wi

3）代码：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <cstring>  
3. #include <algorithm>  
4.   
5. using namespace std;  
6. #define maxV 1000  
7. #define maxU 1000  
8.   
9. int main(void) {  
10.     int cases, n, v, u, ai, bi, wi;  
11.     int f[maxV][maxU];  
12.     freopen("5.txt", "r", stdin);  
13.     cin >> cases;  
14.     while (cases--) {  
15.         memset(f, 0, sizeof(f));  
16.         cin >> n >> v >> u;  
17.         for (int i = 0; i < n; i++) {  
18.             cin >> ai >> bi >> wi;  
19.             for (int j = v; j >= 0; j--) {  
20.                 for (int k = u; k >= 0; k--) {  
21.                     if (ai <= j && bi <= k)  
22.                         f[j][k] = max(f[j][k], f[j - ai][k - bi] + wi);  
23.                 }  
24.             }  
25.         }  
26.         cout << f[v][u] << endl;  
27.     }  
28. }  

4）测试文件：

[plain]  view plain  copy

1. 2  
2. 3 10 5  
3. 1 2 4  
4. 2 1 4  
5. 4 4 6  
6.   
7. 4 5 6  
8. 1 1 3  
9. 1 2 4  
10. 2 1 4  
11. 3 4 7  

6. 分组背包

1）问题：

有n件物品和一个容量为v的背包。
第i件物品的费用是c[i]，价值是w[i]。
这些物品被划分为若干组，每组中的物品互相冲突，最多选一件。
求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

2）输入：

测试用例数 
物品数 背包容量 组数g(组号范围：0 ~ g-1)
第i件物品的ci wi gi(所属组号)

3）代码：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <cstring>  
3. #include <vector>  
4. #include <algorithm>  
5.   
6. using namespace std;  
7. #define maxV 1000  
8. #define maxG 100  
9. #define maxN 100  
10.   
11. int main(void) {  
12.     int cases, n, v, g, gi;  
13.     int f[maxV];  
14.     int ci[maxN], wi[maxN];  
15.     freopen("6.txt", "r", stdin);  
16.     cin >> cases;  
17.     while (cases--) {  
18.         memset(f, 0, sizeof(f));  
19.         cin >> n >> v >> g;  
20.         vector<vector<int> > gMap(g);  
21.         for (int i = 0; i < n; i++) {  
22.             cin >> ci[i] >> wi[i] >> gi;  
23.             gMap[gi].push_back(i);  
24.         }  
25.   
26.         for (int i = 0; i < g; i++) {  
27.             for (int j = v; j >= 0; j--) {  
28.                 for (int k = 0; k < gMap[i].size(); k++) {  
29.                     if (j >= ci[gMap[i][k]])  
30.                         f[j] = max(f[j], f[j - ci[gMap[i][k]]] + wi[gMap[i][k]]);  
31.                 }  
32.             }  
33.         }  
34.   
35.         cout << f[v] << endl;  
36.     }  
37. }  

4）测试文件：

[plain]  view plain  copy

1. 2  
2. 4 10 2  
3. 3 5 0  
4. 4 6 0  
5. 2 7 1  
6. 1 6 1  
7.   
8. 5 10 3  
9. 1 3 0  
10. 2 4 0  
11. 3 5 1  
12. 4 7 1  
13. 5 8 2  

7. 有依赖的背包

1）题目：

这种背包问题的物品间存在某种“依赖”的关系。
也就是说，i依赖于j，表示若选物品i，则必须选物品j。
为了简化起见，我们先设没有某个物品既依赖于别的物品，又被别的物品所依赖；
另外，没有某件物品同时依赖多件物品。

2）输入：

测试用例数 
物品数 背包大小
第i个物品的ci wi di(依赖物品的编号，-1为不依赖其他物品)

3）代码：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <vector>  
3. #include <cstring>  
4. #include <algorithm>  
5.   
6. using namespace std;  
7. #define maxV 1000  
8. #define maxG 100  
9.   
10. int main(void) {  
11.     int cases, n, v, ci[maxV], wi[maxV], di, f[maxV];  
12.     freopen("7.txt", "r", stdin);  
13.     cin >> cases;  
14.     while (cases--) {  
15.         memset(f, 0, sizeof(f));  
16.         cin >> n >> v;  
17.           
18.         // group[i]空表示i号物品有依赖，因此存放到其他组里  
19.         // 只有一个元素表示i号物品既无依赖也不被依赖  
20.         // 有多个元素表示i号物品被依赖，这里自己的编号i也被存放进group[i]  
21.         vector<vector<int> > groups(n);   
22.   
23.         // 读入数据并储存起来  
24.         for (int i = 0; i < n; i++) {  
25.             cin >> ci[i] >> wi[i] >> di;  
26.             if (di == -1) groups[i].push_back(i);  
27.             else groups[di].push_back(i);  
28.         }  
29.   
30.         // 对每个有多个元素的组进行01背包  
31.         for (int i = 0; i < n; i++) {  
32.             if (groups[i].size() > 1) {  
33.                 vector<int> giOri; //group[i]的拷贝，排除i本身  
34.                 int newV = v - ci[i];  
35.   
36.                 // 复制group[i]中的元素，排除i  
37.                 for (int j = 0; j < groups[i].size(); j++) {  
38.                     if (groups[i][j] != i)  
39.                         giOri.push_back(groups[i][j]);  
40.                 }  
41.   
42.                 // 把等效物品组存入group[i]中  
43.                 groups[i].clear();  
44.                 groups[i].resize(newV + 1, 0);  
45.                 for (int j = 0; j < giOri.size(); j++) {  
46.                     for (int k = newV; k >= 0; k--) {  
47.                         if (ci[giOri[j]] <= k) {  
48.                             groups[i][k] = max(groups[i][k], groups[i][k - ci[giOri[j]]] + wi[giOri[j]]);  
49.                         }  
50.                     }  
51.                 }  
52.             }  
53.         }  
54.   
55.         // 进行分组背包  
56.         for (int i = 0; i < n; i++) {  
57.             if (groups[i].size() == 0) continue;  
58.             else if (groups[i].size() == 1) { // i物品无依赖且不被依赖  
59.                 for (int j = v; j >=0; j--) {  
60.                     if (j >= ci[i])  
61.                         f[j] = max(f[j], f[j - ci[i]] + wi[i]);  
62.                 }  
63.             } else { // i物品被依赖, i组第k个物品的cost为k + ci[i], weight为group[i][k] + wi[i]  
64.                 for (int j = v; j >= 0; j--) {   
65.                     for (int k = 0; k < groups[i].size(); k++) {  
66.                         if (j >= k + ci[i])  
67.                             f[j] = max(f[j], f[j - k - ci[i]] + groups[i][k] + wi[i]);  
68.                     }  
69.                 }  
70.             }  
71.         }  
72.           
73.         cout << f[v] << endl;  
74.     }  
75. }  

4）测试文件：

[plain]  view plain  copy

1. 2  
2. 3 10  
3. 3 5 -1  
4. 4 6 0  
5. 7 10 0  
6.   
7. 4 15  
8. 4 1 -1  
9. 6 8 0  
10. 7 10 0  
11. 10 4 -1  

8. 泛化物品

1）题目：

在背包容量为v的背包问题中，泛化物品是一个定义域为0..v中的整数的函数h，当分配给它的费用为v时，能得到的价值就是h(v)。
为了应用泛化物品思想，这里假设题目为：存在依赖关系树（简单起见，只有一个根节点），即有依赖的物品也可以被依赖，可结合原文7.3节来理解此句。

2）输入：

测试用例数
物品数 背包容量 根节点编号
第i个物品的ci wi di(依赖物品的编号，-1为不依赖其他物品)

3）代码：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <algorithm>  
3. using namespace std;  
4. #define maxN 100  
5. #define maxV 1000  
6.   
7. int n, v;  
8. int cnt = 0;  
9. int head[maxN];  
10. int wi[maxN], ci[maxN];  
11. int f[maxN][maxV];  
12.   
13. struct Edge {  
14.     int v, next;  
15. } e[maxN - 1];  
16.   
17. void addEdge(int u, int v) {  
18.     e[cnt].v = v;  
19.     e[cnt].next = head[u];  
20.     head[u] = cnt++;  
21. }  
22.   
23. void treeDP(int u) {  
24.     for (int i = ci[u]; i <= v; i++) {  
25.         f[u][i] = wi[u];  
26.     }  
27.     for (int i = head[u]; i != -1; i = e[i].next) {  
28.         int curr = e[i].v;  
29.         treeDP(curr);  
30.         for (int j = v; j >= 0; j--) {  
31.             for (int k = j - ci[u]; k >= 0; k--) {  
32.                 f[u][j] = max(f[u][j], f[u][j - k] + f[curr][k]);  
33.             }  
34.         }  
35.     }  
36. }  
37.   
38. int main(void) {  
39.     int cases, root;  
40.     freopen("8.txt", "r", stdin);  
41.     cin >> cases;  
42.     while (cases--) {  
43.         cnt = 0;  
44.         memset(head, -1, sizeof(head));  
45.         memset(f, 0, sizeof(f));  
46.         cin >> n >> v >> root;  
47.         for (int i = 0; i < n; i++) {  
48.             int di;  
49.             cin >> ci[i] >> wi[i] >> di;  
50.             addEdge(di, i);  
51.         }  
52.         treeDP(root);  
53.         cout << f[root][v] << endl;  
54.     }  
55. }  

4）测试文件：

[plain]  view plain  copy

1. 2  
2. 5 5 0  
3. 1 2 -1  
4. 2 7 0  
5. 2 5 0  
6. 2 6 2  
7. 1 4 2  
8.   
9. 6 5 0  
10. 1 2 -1  
11. 1 3 0  
12. 2 3 0  
13. 2 4 0  
14. 2 7 2  
15. 3 10 2  

9. 背包问题的变化

1）题目：

输出01背包的具体方案

2）输入：

同01背包

3）代码：

[cpp]  view plain  copy

1. #include <iostream>  
2. #include <algorithm>  
3. using namespace std;  
4. #define maxV 1000  
5. #define maxN 100  
6.   
7. int main(void) {  
8.     int cases, n, v, ci[maxN], wi;  
9.     int f[maxV];  
10.     bool g[maxN][maxV]; //g[i][v]=0 表示没放i时的f(i, v)较大，  
11.                         //g[i][v]=1 表示放进i时的f(i, v)较大  
12.     freopen("9.txt", "r", stdin);  
13.     cin >> cases;  
14.     while (cases--) {  
15.         memset(f, 0, sizeof(f));  
16.         memset(g, 0, sizeof(g));  
17.         cin >> n >> v;  
18.         for (int i = 0; i < n; i++) {  
19.             cin >> ci[i] >> wi;  
20.             for (int j = v; j >= 0; j--) {  
21.                 if (j >= ci[i]) {  
22.                     if (f[j - ci[i]] + wi > f[j]) {  
23.                         f[j] = f[j - ci[i]] + wi;  
24.                         g[i][j] = 1;  
25.                     }  
26.                 }  
27.             }  
28.         }  
29.   
30.         int i = n - 1, j = v;  
31.         while (i >= 0) {  
32.             if (g[i][j] == 1) {  
33.                 cout << "选了" << i << endl;  
34.                 j -= ci[i];  
35.             } else {  
36.                 cout << "没选" << i << endl;  
37.             }  
38.             i--;  
39.         }  
40.         cout << endl;  
41.     }  
42. }  

4）测试文件：

[plain]  view plain  copy

1. 2  
2. 4 10  
3. 2 4  
4. 3 5  
5. 4 6  
6. 5 10  
7.   
8. 5 20  
9. 3 2  
10. 7 3  
11. 10 5  
12. 15 6  
13. 16 10  

参考： 参考1  参考2