背包九讲总结

最新推荐文章于 2022-04-03 17:17:55 发布

量子孤岛

最新推荐文章于 2022-04-03 17:17:55 发布

阅读量385

点赞数

分类专栏： Data Structure and Algorithms 文章标签： backpack

本文链接：https://blog.csdn.net/fly_wt/article/details/90231240

版权

Data Structure and Algorithms 专栏收录该内容

16 篇文章 1 订阅

订阅专栏

背包九讲

01背包问题
完全背包问题
多重背包问题
混合背包问题
二维费用的背包问题
分组背包问题
背包问题方案数
求背包问题的方案
有依赖的背包问题

1. 01背包问题

给定n中物品和容量为C的背包，物品i的重量的wi，其价值为vi。

面对每个物品，我们只有选择拿与不拿，不能选择装入物体的一部分，也不能装入同一个物品多次。

决策：为了背包中物品总价值最大化，第 i件物品应该放入背包中吗？

状态转移方程

f[i][j] 表示前 i 件物品放入一个容量为 j 的背包获得的最大价值.

j < w[i] ,此时背包容量不足以放下第i件物品，只能选择不拿——f[i][j] = f[i-1][j]
j >= w[i] ,这时背包容量可以放下第 i 件物品，我们就要考虑拿这件物品是否能获取更大的价值。
- 若拿取，f[i][j] = f[i - 1][j - w[i]] + v[i].这里的f[i - 1][ j - w[i]]指的就是考虑了i-1件物品，背包容量为j-w[i]时的最大价值。
- 若不拿——f[i][j] = f[i-1][j]

例子

假设山洞里共有a,b,c,d ,e这5件宝物（不是5种宝物），它们的重量分别是2,2,6,5,4，它们的价值分别是6,3,5,4,6，现在给你个承重为10的背包, 怎么装背包，可以才能带走最多的财富。

重点：明确这张表是至底向上，从左到右生成的.1~10代表承重，单元格则代表价值

name	weight	value	2	3	4	5	6	7	8	9	10
a	2	6	6	6	9	9	12	12	15	15	15
b	2	3	3	3	6	6	9	9	9	10	11
c	6	5	0	0	6	6	6	6	6	10	11
d	5	4	0	0	6	6	6	6	6	10	10
e	4	6	0	0	6	6	6	6	6	6	6

版本1：利用二维数组

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 1010;
// 全局变量定义在堆上，会初始化为0
int n, capacity;
int f[N][N];
int v[N], w[N]; // 记录一下每个物品的体积和价值

int main()
{
    cin >> n >> capacity;
    for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];
    
    for (int i = 1; i <= n; i++)
        for (int j =1; j <= capacity; j++)
        {
            f[i][j] = f[i-1][j];
            if (j >= v[i])
                f[i][j] = max(f[i][j], f[i -1][j - v[i]] + w[i]);
        }    
    int res = 0;
    for (int i = 0; i <= capacity; i++) res = max(res, f[n][i]);
    
    cout << res << endl;
    return 0;
}

观察发现：f[i][v]只和前一层有关，没有必要把所有层都记下来。
用滚动数组或者一维数组来优化

版本2：

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 1010;
// 全局变量定义在堆上，会初始化为0
int n, capacity;
int f[N];
int v[N], w[N]; // 记录一下每个物品的体积和价值

int main()

{
       cin >> n >> capacity;
       for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];


       for (int i = 1; i <= n; i++)
             for (int j = capacity; j >= v[i]; j--) // 从大到小排列保证不包含第i个物品
                    f[j] = max(f[j], f[j - v[i]] + w[i]);

       cout << f[capacity] << endl;  // 和初始化有关
       /*
       f[0] = 0;
       f[i] = -INF;    
       */
       return 0;

}

2. 完全背包问题

有 N 种物品和一个容量是 V的背包，每种物品都有无限件可用。

第 i 种物品的体积是 v[i]，价值是 w[i]。

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

/*
f[i] 表示  总体积是i的情况下最大价值是多少
result = max(f[0 ... m]) m代表容量

for (int i =1; i <= n; i++)
	for (int j = v[i]; j <= m; j--)  // 从小到大枚举保证能取到重复的
		f[j] = max(f[j], f[j - v[i]] + w[i]);
*/

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 1010;

int f[N];
int v[N], w[N];

int main()
{
    int n, capacity;
    cin >> n >> capacity;
    for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];
    
    // 明确状态转换方程
    for (int i = 1; i <= n; i++)
        for (int j = v[i]; j <= capacity; j++)
            f[j] = max(f[j], f[j - v[i]] + w[i]);
            
    cout << f[capacity] << endl; // 表示前m个之和，因为全局初始化已经保证了所有f[i]都是0
    // 如果题目为背包容积恰为capacity的最大价值为多少，只需把所有值初始化为-INF;
    return 0;
            
}

3. 1 多重背包问题 I

此问题是01背包问题的扩展

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

第 i 种物品最多有 s[i] 件，每件体积是 v[i]，价值是 w[i]。

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

数据范围

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

由数据范围可以用三重循环来做,最简单的写法

/*
f[i] = 总体积是i的情况下，最大价值是多少

for (int i = 0; i < n; i++)
{
	for (int j = m; j >= v[i]; j--)
		f[j] = max(f[j], f[j - v[i]] + w[i], f[j - 2*v[i]] + 2*w[i] ...);
}

1. f[i] = 0;
f[m]就是答案

2. f[0] = 0;  f[i] = -INF, i != 0;
max(f[0...m]);
*/

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;
const int N = 110;
int f[N];
int v[N], w[N], s;

int main()
{
    int n, m;
    cin >> n >> m ;
    
    for (int i = 1; i <= n; i++)
    {
        cin >> v[i] >> w[i] >> s;
        for (int j = m; j >= v[i]; j--)
            for (int k = 1; k <= s && k*v[i] <= j; k++ )
                f[j] = max(f[j], f[j - k*v[i]] + k*w[i]);
    }
    cout << f[m] << endl;
    return 0;
}

3.2 多重背包问题 II

题目同上。但是数据范围较大。

数据范围

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

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

考虑：如何把多重背包问题变成01背包问题

将s划分成log s 份，

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>

using namespace std;

const int N = 2010;

int n, m;
int f[N];

struct Good
{
    int v, w;
};

int main()
{
    vector<Good> goods;
    cin >> n >> m;
    
    for (int i = 0; i < n; i++)
    {
        int v, w, s;
        cin >> v >> w >> s;
        // 把s拆成logS份
        for (int k = 1; k <= s; k*=2)
        {
            s -= k;
            goods.push_back({v * k, w * k});
        }
        if (s > 0) goods.push_back({v * s, w * s});
    }
    
    // 套用01背包的模板即可
    for (auto good : goods)
        for (int j = m; j >= good.v; j--)
            f[j] = max(f[j], f[j - good.v] + good.w);
            
            
    cout << f[m] << endl;
    return 0;
}

3.3 多重背包问题 III

单调队列优化解法， LeetCode239题

using namespace std;

int item_number, packge_volumn;
int volume, value, number;

int dp[20010];
int dp_prev[20010];
int monotone_queue[20010];

int main() {
    cin >> item_number >> packge_volumn;
    for (int i = 0; i < item_number; ++i) {
        memcpy(dp_prev, dp, sizeof(dp));
        cin >> volume >> value >> number;
        for (int j = 0; j < volume; ++j) {
            int head = 0, tail = -1;
           /*
            数值越大，表示位置越后面
            队首在队尾后面队列为空，即head > tail 时队列为空
          
             monotone_volumn[]为单调队列
            存储前个s(物品数量)中的最大值
            数组从头(hh)到尾(tt)单调递减
            */
            for (int k = j; k <= packge_volumn; k += volume) {
                 //k代表假设当前背包容量为k
                //monotone_queue[head]为队首元素（最大值的下标）
                //g[]为dp[i-1][]
                //f[]为dp[i][]

                /*
                维护一个大小为k的区间使最大值为前k个元素中最大
                (k - q[hh]) / v 表示拿取物品的数量（相当于最原始的多重背包dp的k）
                */
                if (head <= tail && (k - monotone_queue[head]) / volume > number)
                    head++;
               /*
                若队内有值，该值就是前k个元素的最大值
                (k - q[hh]) / v 表示拿取物品的数量（相当于最原始的多重背包dp的k）
                q[hh]为队首元素（g[]中前k个数中最大值的下标），g[]为dp[i-1][]
                所以 g[q[hh]]为只考虑前i-1个物品时，拿前q[hh]个物品的最大价值
                */
                if (head <= tail)
                    dp[k] = max(dp[k], dp_prev[monotone_queue[head]] + (k - monotone_queue[head]) / volume * value);
 				
                /*
                若队尾元素小于当前元素，则队尾元素出队；
                若队内一个元素比当前元素小，则该元素一定不会被用到（单调队列思想）
                g[q[hh]] + (k - q[hh]) / v * w 
                与
                g[k] - (k - j) / v * w
                分别表示队尾元素的值和当前元素的值
                */
                while (head <= tail && dp_prev[monotone_queue[tail]] - (monotone_queue[tail] - j) / volume * value<= dp_prev[k] - (k - j) / volume * value) {
                    --tail;
                }
//去除了比当前小的元素，保证队列里的元素都比当前元素大，入队
                monotone_queue[++tail] = k;
            }
        }
    }
    cout << dp[packge_volumn] << endl;
}

4. 混合背包问题

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

物品一共有三类：

第一类物品只能用1次（01背包）；
第二类物品可以用无限次（完全背包）；
第三类物品最多只能用 si 次（多重背包）；

每种体积是 vi，价值是 wi。

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

输入格式

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

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

si=−1 表示第 i种物品只能用1次；
si=0 表示第 i 种物品可以用无限次；
si>0 表示第 i 种物品可以使用 si 次；

输出格式

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

#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>

using namespace std;
const int N = 1010;
int f[N];

struct Thing
{
    int kind;
    int v, w;
};
vector <Thing> things;

int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++)
    {
        int v, w, s;
        cin >> v >> w >> s;
        if (s < 0)  things.push_back({-1, v, w});
        else if (s == 0)  things.push_back({0, v, w});
        else
        {
            for (int k = 1; k <= s; k *= 2)
            {
                s -= k;
                things.push_back({-1, v*k, w*k});
            }
            if (s > 0) things.push_back({-1, v*s, w*s});
        }
    }
    
    for (auto thing : things)
    {
        if (thing.kind == 0)
        {
             for (int j = thing.v; j <= m; j++ )   f[j] = max(f[j], f[j - thing.v] + thing.w);
           
        }
        else 
        {
            for (int j = m; j >= thing.v; j--)  f[j] = max(f[j], f[j - thing.v] + thing.w);
        }
        
    }
    cout << f[m] << endl;
    return 0;
}

4. 二维背包问题

有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。

每件物品只能用一次。体积是 vi，重量是 mi，价值是 wi。

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

输入格式

第一行两个整数，N，V,M，用空格隔开，分别表示物品件数、背包容积和背包可承受的最大重量。

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

输出格式

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

数据范围

0<N≤1000
0<V,M≤100
0<vi,mi≤100
0<wi≤1000

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;
int f[N][N];

int nums, volumns, weights;

int main()
{
    cin >> nums >> volumns >> weights;
    for (int i = 0; i < nums; i++)
    {
        int  volumn, weight, value;
        cin  >> volumn >> weight >> value;
            for (int j = volumns; j >= volumn; j-- )
                for (int k = weights; k >= weight; k--)
                f[j][k] = max(f[j][k], f[j - volumn][k - weight] + value);
    }
    cout << f[volumns][weights] << endl;
    return 0;
}

6. 分组背包问题

这里面多了一个背包组概念，且同一个背包组里面的物品之间是互斥的。01背包问题的变种

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

每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vij，价值是 wij，其中 i是组号，j是组内编号。

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

输出最大价值。

输入格式

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

接下来有 N 组数据：

每组数据第一行有一个整数 Si，表示第 i 个物品组的物品数量；
每组数据接下来有 Si 行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i个物品组的第 j个物品的体积和价值；

输出格式

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

数据范围

0<N,V≤100
0<Si≤100
0<vij,wij≤100

输入样例

输出样例：

#include <iostream>

量子孤岛

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
背包九讲总结

背包九讲01背包问题完全背包问题多重背包问题混合背包问题二维费用的背包问题分组背包问题背包问题方案数求背包问题的方案有依赖的背包问题1. 01背包问题给定n中物品和容量为C的背包，物品i的重量的wi，其价值为vi。面对每个物品，我们只有选择拿与不拿，不能选择装入物体的一部分，也不能装入同一个物品多次。决策：为了背包中物品总价值最大化，第 i件物品应该放入背包中吗？...
复制链接

扫一扫