背包九讲（附Cpp代码）

最新推荐文章于 2021-04-29 09:45:37 发布
最新推荐文章于 2021-04-29 09:45:37 发布
阅读量548 收藏 2
点赞数
分类专栏： c++ 算法与数据结构 文章标签： c++ 01背包
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010525694/article/details/78301823
版权
这篇博客详细讲解了01背包、完全背包、多重背包、混合三种背包、二维费用的背包、分组背包、有依赖的背包、泛化物品和背包问题的变化等九种背包问题，并附带了每种问题的C++代码实现和测试文件，是学习和理解背包问题的好资料。
摘要由CSDN通过智能技术生成

文档链接：

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
Dev-L
关注
专栏目录
算法竞赛资料整理分享
BIT`S WORLD
06-11 1873
算法竞赛资料分享????????‍♀️ 因为准备实习????，今天早上整理了一下算法的课件、书籍、论文、习题 不管是准备校招，进BAT????； 还是自学算法竞赛????； 或者单纯的课外拓展????； 对程序员????而言，算法学习都是有必要的，只是可能要求深浅不同，所以，开始学起来吧????～ 仓库在这里，感谢您的star！ 全面收集、整理了从高中参加竞赛到现在的算法竞赛课件、论文集、书籍、习题等，并分类如下????： 欢迎大家贡献你的资料丰富这个Repo 文件很多，目录很长，所以分为文件夹目录
背包九讲和代码
12-01
背包九讲和代码背包九讲和代码背包九讲和代码背包九讲和代码背包九讲和代码
背包九讲代码总结
weach的博客
03-28 226
代码模板总结： #include<bits/stdc++.h> using namespace std; typedef long long ll; const ll maxn = 1000005; ll dp[maxn]; ll cost[maxn], weight[maxn], amount[maxn]; ll n, v; void ZeroOnePack(ll cost, ll weight) { for (ll j = v; j >= cost; --j)//逆序枚举
AcWing--2.01背包问题
hx1043116928的博客
11-07 313
有NN件物品和一个容量是VV的背包。每件物品只能使用一次。 第ii件物品的体积是vivi，价值是wiwi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，VN，V，用空格隔开，分别表示物品数量和背包容积。 接下来有NN行，每行两个整数vi,wivi,wi，用空格隔开，分别表示第ii件物品...
DP回顾——背包问题
pxlsdz的博客
12-02 1592
背包问题 N 件物品放入容量为 V 的背包，求最大的价值。 常见的背包问题分为：01背包问题，完全背包问题 其中核心的问题还是 01背包问题，其余的背包问题都是基于01背包的变形。 AcWing 2. 01背包问题 有 N件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每
背包九讲代码
weixin_44391390的博客
08-02 166
1、01背包。 2、完全背包 3、多重背包
01背包问题
weixin_51160138的博客
04-29 324
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出最大价值。 输入格式 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出格式 输出一个整数，表示最大价值。 数据范围 0<N,V≤1000 0<vi,wi≤1000 输入样例 4 5 1 2 2
动态规划-背包九讲（结合代码）
肉丸不肉
03-27 482
一、01背包 有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。 每种物品仅有一件，可以选择放或不放。 二、完全背包 有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最...
背包九讲
qq_40438165的博客
01-26 1295
一、01背包 要求：每种物品只能选择0个或1个，即对于每种物品只有选或者不选两种情况。 题目描述：(题目链接) \quad有 NNN 件物品和一个容量是 VVV 的背包。每件物品只能使用一次。第 iii 件物品的体积是 viv_ivi​，价值是 wiw_iwi​。求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。输出最大价值。 输入格式： \quad第一行两个整数，N，VN...
背包九讲（仅提供代码回忆）
weixin_30906425的博客
08-22 133
题集传送门（1~12） （壹）01背包 有N个物品和一个体积为V的背包，每个物品体积为v[i]，价值为w[i]，问背包可收纳的最大价值。 时间复杂度O(N*V)。 1 /* 2 f[m]即为答案。 3 如果要表示恰好去体积为V的物品， 4 可以把除f[0]外全置为负无穷， 5 以保证是f[m]从f[0]推来的。 6 */ 7 #include&l...
0-1背包问题.cpp
03-06
C语言四种方法实现背包问题，可以直接运行，代码简单高效，属实精品。。
01背包.cpp
06-15
01背包的解法，详细介绍了如何动态规划的初步入门，如何找到最优子集，找到最优的解法。
背包九讲完整版c++
12-25
背包九讲完整版c++ 第一讲01背包问题 第二讲完全背包问题 第三讲多重背包问题 第四讲混合三种背包问题 第五讲二维费用的背包问题 第六讲分组的背包问题 第七讲有依赖的背包问题 第八讲泛化物品 第九讲背包问题问法的变化 附： USACO中的背包问题
动态规划背包问题.cpp
06-06
动态规划背包问题.cpp
01背包（回溯）.cpp
01-20
经典算法01背包问题，通过回溯来求解
[AcWing]，背包九讲---过程推导+代码实现（全面）
duchenlong的博客
01-28 509
详细解释ACWing中的所有背包问题，从01背包，完全背包，混合背包，三种多重背包，组合背包，有依赖的背包，二维费用的背包，背包问题的方案数，最小字典序的方案问题，给出DP的推导过程+原理
背包九讲——完全背包
六炅的专栏
08-02 604
1.问题描述 有N种武平和一个容量为V的背包，每种物品都有无限件可以使用。放入第i种物品消耗的空间是Ci，得到的价值是Wi。求解：将那些物品装入背包，可使这些物品耗费的空间总和不超过背包容量，且价值最大。 举例：背包容量V=5，有三个物品N=3，重量分别为3，2，2;价值分别为5，10，20。 2.问题思路 这个问题和01背包其实是十分相似的，只不过是每种物品可以取0件，1件，2件，，，V/
背包九讲完整版_背包九讲
07-15
背包九讲的完整版，详细介绍了背包问题。
背包问题 (Knapsack.cpp)
AengusChen的博客
07-30 1159
背包问题  (Knapsack.cpp) 【题目描述】 给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择，才能使得物品的总价格最高。问题的名称来源于如何选择最合适的物品放置于给定背包中。   【解题思路】 运用贪心算法，每次挑选目前单价最高且重量未超过背包剩余容量的物品。允许装入物品的一部分。 【输入】 输入文件Knapsack.in中第一行包含2个整数
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值