背包问题【01、完全(恰好or不超过)、多重】【尚未整理完】

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/Dr_Unknown/article/details/51275471

变形问题:2N长度数组,分成俩N长度的,使其和差值最小。

 

程序员面试100题之十五:数组分割


要点:

仨黄色背景代码为三个问题最终用的模板)

1.一维的01背包为啥要逆序(保证更新f[j]时,f[ j - weight[i] ]是没有放入物品i时的数据即f[ i - 1 ][ j - weight[i] ],因为01背包每个物品至多被选一次。而完全背包中,每个物品可以被选无限次,那么状态f[i][j],正好可以由可能已经放入物品i的状态f[ i - 1 ][ j - weight[i] ]转移而来。所以,遍历顺序改为顺序时,就是完全背包问题,其余都不用变~


2.完全背包 和 01背包 的区别在于状态更新时的遍历顺序。(即01是逆序,完全是顺序)


3.不超过容量 和 恰好装满 的区别在于二者的初始化~(前者全0;后者,f[i][0] = 0(第一列),其余全为0x80000000,一维:除f[0]为0外,其余f[j]都是负无穷)


4.循环边界  i:【1,N】,j:【V,weight[i]】(下文有讲,还有更优化的..不过看不懂)


5.多重背包问题可以拆分为 01背包 与 完全背包 的组合。


6.打印出装的顺序(下文有讲 尚未看)




原文说的很详细甚至到了啰嗦的地步..持续整理中...= =b


以下整理自:背包问题九讲笔记_01背包


摘自Tianyi Cui童鞋的《背包问题九讲》,稍作修改,方便理解。

01背包问题描述

已知:有一个容量为V的背包和N件物品,第i件物品的重量是weight[i],收益是value[i]。

限制:每种物品只有一件,可以选择放或者不放

问题:不超过背包容量的情况下,最多能获得多少价值或收益

变型问题:恰好装满背包的情况下,最多能获得多少价值或收益

这里,我们先讨论在不超过背包容量的情况下,最多能获得多少价值或收益。

基本思路分析

考虑我们的子问题,将前i件物品放到容量为v的背包中,若我们只考虑第i件物品时,它有两种选择,放或者不放。

1) 如果第i件物品不放入背包中,那么问题就转换为:将前i - 1件物品放到容量为v的背包中,带来的收益f[i - 1][v]

2) 如果第i件物品能放入背包中,那么问题就转换为:将前i - 1件物品放到容量为v - weight[i]的背包中,带来的收益f[i - 1][v - weight[i]] + value[i]

代码view plai

#include <iostream>  
using namespace std;  
  
const int N = 3;//物品个数  
const int V = 5;//背包最大容量  
int weight[N + 1] = {0,3,2,2};//物品重量  
int value[N + 1] = {0,5,10,20};//物品价值  
  
int f[N + 1][V + 1] = {{0}}; 
  
/* 
目标:在不超过背包容量的情况下,最多能获得多少价值 
 
子问题状态:f[i][j]:表示前i件物品放入容量为j的背包得到的最大价值 
 
状态转移方程:f[i][j] = max{f[i - 1][j],f[i - 1][j - weight[i]] + value[i]} 
 
初始化:f数组全设置为0 
*/  
int Knapsack()  
{  
    //初始化  
    memset(f,0,sizeof(f));  
    //递推  
    for (int i = 1;i <= N;i++) //枚举物品。i为0时无意义,故f[0][j] = 初始值0  
    {  
        for (int j = V;j >= 0;j++) //枚举背包容量  
        {  
            f[i][j] = f[i - 1][j];  //j<weight[i]时,状态仅能来自于<span style="font-family: Arial, Helvetica, sans-serif;">f[i - 1][j]</span>
            if (j >= weight[i])  
            {  
                f[i][j] = max(f[i - 1][j],f[i - 1][j - weight[i]] + value[i]);  
            }  
        }  
    }  
    return f[N][V];  
}  


 copy

效率分析:

此算法的时间复杂度为O(N*V),空间复杂度也为O(N*V)。其中,N 表示物品个数,V 表示背包容量。

这里,时间复杂度不可以在优化了,但是空间复杂度可以继续优化到O(V)。

优化空间复杂度

上述的方法,我们使用二维数组 f[i][v] 保存中间状态,这里我们可以使用一维数组f[v]保存中间状态就能得到结果。

分析

f[i][j] = max(f[i - 1][j],f[i - 1][j - weight[i]] + value[i]),我们可以看出,状态的转移仅与上一行(i-1行)有关。

我们现在使用f[v]保存中间状态,我们想要达到的效果是,第i次循环后,f[v]中存储的是前i个物体放到容量v时的最大价值

当我们使用一维数组存储状态时,f[v]表示,在执行i次循环后(此时已经处理i个物品),前i个物体放到容量v时的最大价值,即之前的f[i][v]。与二维相比较,它把第一维隐去了,但是二者表达的含义还是相同的,只不过针对不同的i,f[v]一直在重复使用,所以,也会出现第i次循环可能会覆盖第i - 1次循环的结果。

为了求f[v],我们需要知道,前i - 1个物品放到容量v的背包中带来的收益,即之前的f[i - 1][v] 和 前i - 1件物品放到容量为v - weight[i]的背包中带来的收益,即之前的f[i - 1][v - weight[i]] + value[i]。

难点

由于我们只使用一维数组存储,则在求这两个子问题时就没有直接取出那么方便了,因为,第i次循环可能会覆盖第i - 1次循环的结果。

现在我们来求这两个值:

1)前i-1个物品放到容量v的背包中带来的收益,即之前的f[i - 1][v] :

由于,在执行在i次循环时,f[v]存储的是前i个物体放到容量v时的最大价值,在求前i个物体放到容量v时的最大价值(即之前的f[i][v])时,我们是正在执行第i次循环,f[v]的值还是在第i-1次循环时存下的值,在此时取出的 f[v]就是前i-1个物体放到容量v时的最大价值,即f[i - 1][v]。

2)前i-1件物品放到容量为v-weight[i]的背包中带来的收益,即之前的f[i-1][v-weight[i]] + cost[i]

由于,在执行第i次循环前,f[0] ~ f[V]中保存的是第i - 1次循环的结果,即是前i - 1个物体分别放到容量0 ~ V时的最大价值,即f[i - 1][0] ~f[i - 1][V]。

则,在执行第i次循环前,f 数组中v - weight[i]的位置存储就是我们要找的 "前i - 1件物品放到容量为v - weight[i]的背包中带来的收益" (即之前的f[i - 1][v - weight[i]]),这里假设物品是从数组下标1开始存储(全文皆是)

伪代码

for i=1..N //枚举物品  
    for v=V..0 //枚举容量,从大到小  
        f[v]=max{f[v],f[v-weight[i]] + cost[i]};  

由上面伪代码可知,在执行第 i 次循环时,需要把背包容量由V..0都要遍历一遍,检测第 i 件物品是否能放。

逆序枚举容量的原因:

注意一点,我们是由第i-1次循环的两个状态推出 第i个状态的,而且 v  > v - weight[i],则对于第i次循环,背包容量只有当V..0循环时,才会先处理背包容量为v的状况,后处理背包容量为 v-weight[i] 的情况。

具体来说,由于在执行v时,还没执行到v - weight[i],因此,f[v - weight[i]]保存的还是第i-1次循环的结果。即在执行第i次循环 且 背包容量为v时,此时的f[v]存储的是 f[i - 1][v] ,此时f[v-weight[i]]存储的是f[i - 1][v-weight[i]]。

相反,如果在执行第 i 次循环时,背包容量按照0..V的顺序遍历一遍,来检测第 i 件物品是否能放。此时在执行第i次循环 且 背包容量为v时,此时的f[v]存储的是 f[i - 1][v] ,但是,此时f[v-weight[i]]存储的是f[i][v-weight[i]]。

因为,v  > v - weight[i],第i次循环中,执行背包容量为v时,容量为v - weight[i]的背包已经计算过,即f[v - weight[i]]中存储的是f[i][v - weight[i]]。即,对于01背包,按照增序枚举背包容量是不对的。

01背包问题,不超过总容量的一维代码

#include <iostream>  
using namespace std;  
  
const int N = 3;//物品个数  
const int V = 5;//背包最大容量  
int weight[N + 1] = {0,3,2,2};//物品重量  
int value[N + 1] = {0,5,10,20};//物品价值  
  
int f[V + 1] = {0};  
  
/* 
目标:在不超过背包容量的情况下,最多能获得多少价值 
 
子问题状态:f[j]:表示前i件物品放入容量为j的背包得到的最大价值 
 
状态转移方程:f[j] = max{f[j],f[j - weight[i]] + value[i]} 
 
初始化:f数组全设置为0 
*/  
int ZeroOnePack()  
{  
    //初始化  
    memset(f,0,sizeof(f));  
    //递推  
    for (int i = 1;i <= N;i++) //枚举物品  
    {  
        for (int j = V;j >= weight[i];j--) //枚举背包容量,防越界,j下限为 weight[i]!!!  
        {  
            f[j] = max(f[j],f[j - weight[i]] + value[i]);  
        }  
    }  
    return f[V];  
}  


增序枚举背包容量会达到什么效果?它会重复的装入某个物品,而且尽可能多的,使价值最大,当然不会不超过背包容量

而逆序枚举背包容量:背包中的物品至多装一次,使价值最大,当然不会不超过背包容量

我们首先举例说明:

逆序枚举物品:

当i = 2,我们要求 f [5]:表示检测物品2放入容量为5的背包的最大收益

上图表示,当i = 2,求f[5]时f数组的状况,

橙色为数组现在存储的值,这些值是i = 1时(上一次循环)存入数组 f 的。相当于f[i - 1][v]

而黄色使我们要求的值,在求f[5]之前,f[5]= 5,即f[i - 1][5] = 5

现在要求 i = 2 时的f[5] = f[5 - 2] + 10 = 5 + 10 = 15  >  f[i - 1][5] = 5

故,f[5] = 15;

注意一点,在求f[v]时,它引用的 f[v - weight[i]] 和 f[v]都是上一次循环的结果

顺序枚举物品

当i = 2,我们要求 f [5]:表示检测物品2放入容量为5的背包的最大收益

上图表示,当i = 2,求f[5]时f数组的状况,

橙色为数组现在存储的值,这些值是i = 2时(本次循环)存入数组 f 的。相当于f[i][v]

这是由于,我们是增序遍历数组f的,在求f[v]时,v之前的值(0 ~ v - 1)都已经在第i次循环中求出。

而黄色使我们要求的值,在求f[5]之前,f[5]= 5,即f[i - 1][5] = 5

现在要求 i = 2 时的f[5] = f[5 - 2] + 10 =10+ 10 = 20 >  f[i - 1][5] = 5

故,f[5] = 20;

其中引用的f[3]是相当于f[i][3] 而不是正常的f[i - 1][3]

注意一点,在求f[v]时,它引用的 f[v - weight[i]]是本次循环的结果 而f[v]是上一次循环的结果

换个角度说,

在检测 背包容量为5时,看物品2是否加入

由状态转移方程可知,我们f[5]需要引用自己本身和f[3]

由于背包容量为3时,可以装入物品2,且收益比之前的大,所以放入背包了。

在检测f[5]时,肯定要加上物品2的收益,而f[5]在引用f[3]时,f[3]时已经加过一次物品2,

因此,在枚举背包容量时,物品2会加入多次。

进一步说:

我们观察一维状态转移方程:

f[i][v] = max(f[i - 1][v],f[i - 1][v - weight[i]] + cost[i])

首先我们明确三个问题

1) v - weight[i] < v

2) 状态f[i][v] 是由 f[i - 1][v] 和 f[i - 1][v - weight[i]] 两个状态决定

3) 对于物品i,我们在枚举背包容量时,只要背包容量能装下物品i 且 收益比原来的大,就会成功放入物品i。

具体来说,枚举背包容量时,是以递增的顺序的话,由于 v - weight[i] < v,则会先计算 v - weight[i]。在背包容量为v - weight[i]时,一旦装入了物品i,由于求f[v]需要使用f[i - 1][v - weight[i]],而若求f[v]时也可以装入物品i的话,那么在背包容量为v时,容量为v的背包就装入可两次物品。又若v - weight[i]是由之前的状态推出,它们也成功装入物品i的话,那么容量为v的背包就装入了多次物品i了。

注意,此时,在计算f[v]时,已经把物品i能装入的全装入容量为v的背包了,此时装入物品i的次数为最大啊

其实,顺序枚举容量是完全背包问题最简捷的解决方案。

 

初始化的细节问题

求最优解的背包问题时,有两种问法:

1)在不超过背包容量的情况下,最多能获得多少价值

2)在恰好装满背包的情况下,最多能获得多少价值

主要的区别为是否要求恰好装满背包。但这两种问法的实现方法是在初始化的时候有所不同。

1)恰好装满背包的情况:使用二维数组f[i][v]存储中间状态,其中第一维表示物品,第二维表示背包容量

初始化时,除了f[i][0] = 0(第一列)外,其他全为负无穷。

原因:初始化 f 数组就是表示:在没有任何物品可以放入背包时的合法状态。对于恰好装满背包,只有背包容量为 0(第一列),可以什么物品都不装就能装满,这种情况是合法情况,此时价值为0。其他f[0][v](第一列)是都不能装满的,此时有容量没物品。而其他位置(除去第一行和第一列的位置),我们为了在计算中比较最大值,也要初始化为负无穷。我们从程序的角度上看,我们只允许装入背包物品的序列的起始位置是从第一列开始,这些起始位置都是合法位置,且能恰好装满的情况收益均为正值,到f[N][V]终止。

注意,我们虽然是求恰好装满,还是需要枚举所有可以装入背包的物品,只要能装入,还需装入,收益有增加。只不过,由于恰好装满的物品的序列肯定是从第一列某行开始的,且之后的收益肯定是正值。对于非恰好装满的物品序列,其实位置肯定是从第一行某位置开始的,由于此时被初始化为负无穷,在和那些恰好装满物品序列带来的价值时,肯定是小的。所以,我们最后能获得最大值。

01背包恰好装满二维代码:

#include <iostream>  
using namespace std;  
  
const int MinNum = 0x80000000;  
  
const int N = 3;//物品个数  
const int V = 5;//背包最大容量  
int weight[N + 1] = {0,3,2,2};//物品重量  
int value[N + 1] = {0,5,10,20};//物品价值  
  
int f[N + 1][V + 1] = {{0}};  

/* 
目标:在恰好装满背包的情况下,最多能获得多少价值 
 
子问题状态:f[i][j]:表示前i件物品放入容量为j的背包得到的最大价值 
 
状态转移方程:f[i][j] = max{f[i - 1][j],f[i - 1][j - weight[i]] + value[i]} 
 
初始化:f数组全设置为0 
*/  
int ZeroOnePack()  
{  
    //初始化  
    for (int i = 0;i <= N;i++) //枚举物品  
    {  
        for (int j = 0;j <= V;j++) //枚举背包容量  
        {  
            f[i][j] = MinNum;  
        }  
    }  
    for (int i = 0;i <= N;i++)  
    {  
        f[i][0] = 0;//背包容量为0时为合法状态  
    }  
    //递推  
    for (int i = 1;i <= N;i++) //枚举物品  
    {  
        for (int j = 1;j <= V;j++) //枚举背包容量  
        {  
            f[i][j] = f[i - 1][j];  
            if (j >= weight[i])  
            {  
                f[i][j] = max(f[i - 1][j],f[i - 1][j - weight[i]] + value[i]);  
            }  
        }  
    }  
    return f[N][V];  
}  
  
int main()  
{  
    cout<<ZeroOnePack()<<endl;//输出25  
    system("pause");  
    return 1;  
}  


使用一维数组f[v]存储中间状态,维表示背包容量

初始化时,除了f[0] = 0,其他全为负无穷。

原因:只有容量为0 的背包可以什么物品都不装就能装满,此时价值为0。其它容量的背包均没有合法的解,属于未定义的状态,应该被赋值为负无穷了

01背包问题,恰好装满的一维代码

#include <iostream>  
using namespace std;  
  
const int MinNum = 0x80000000;//int最小的数  
  
const int N = 3;//物品个数  
const int V = 5;//背包最大容量  
int weight[N + 1] = {0,3,2,2};//物品重量  
int value[N + 1] = {0,5,10,20};//物品价值  
  
int f[V + 1] = {0};
  
/* 
目标:在恰好装满背包容量的情况下,最多能获得多少价值 
 
子问题状态:f[j]:表示前i件物品放入容量为j的背包得到的最大价值 
 
状态转移方程:f[j] = max{f[j],f[j - weight[i]] + value[i]} 
 
初始化:f数组全设置为0 
*/  
int ZeroOnePack()  
{  
    //初始化  
    for (int i = 0;i <= V;i++)  
    {  
        f[i] = MinNum;  
    }  
    f[0] = 0;//只有背包容量为0时才是合法状态,由合法状态组成的结果才是合法的  
  
    //递推  
    for (int i = 1;i <= N;i++) //枚举物品  
    {  
        for (int j = V;j >= weight[i];j--) //枚举背包容量,防越界,j下限为 weight[i]  
        {  
            f[j] = max(f[j],f[j - weight[i]] + value[i]);  
        }  
    }  
    return f[V];  
}  
  
int main()  
{  
    cout<<ZeroOnePack()<<endl;//输出25  
    system("pause");  
    return 1;  
}  

2)不需要把背包装满,只需要收益最大

使用二维数组f[i][v]存储中间状态,其中第一维表示物品,第二维表示背包容量

初始化时,除了f[i][0] = 0(第一列)外,其他全为负无穷。

使用一维数组f[v]存储中间状态,维表示背包容量

原因:如果背包并非必须被装满,那么任何容量的背包都有一个合法解“什么都不装”,这个解的价值为0,所以初始时状态的值也就全部为0了。

代码在最前面已贴,不在此上传。

一个常数优化

一维数组描述状态时的伪代码:

for i=1..N //枚举物品  
    for v=V..0 //枚举容量,从大到小  
        f[v]=max{f[v],f[v-weight[i]] + cost[i]};  

观察可知,对于第i个物品,枚举背包容量下限时,可以到weight[i]为止。

原因:

1)对于第i物品,在求f[v]时,需要使用的状态是 v ~ v -  weight[i] 这么多,这是由于v取最大容量V时,使用的状态才是v - weight[i],当v不取最大状态时,使用的状态肯定是在v ~ v -  weight[i]之间的。可以到weight[i]为止。

2)在到weight[i]为止时,还可以不进行if判断,担心v -  weight[i]是否越界

此时,伪代码为

for i=1..N //枚举物品  
    for v=V..weight[i] //枚举容量,从大到小  
        f[v]=max{f[v],f[v-weight[i]] + cost[i]};  

注意,对 f 数组,如果是检测第i个物品是否能放入,0 ~ weight[i] - 1的这些位置是不会遍历到的,则此时他们仍表示第i - 1次的状态,即二维的f[i - 1][v]。

还可以继续优化下界为

for i=1..N //枚举物品  
    bound=max{V-sum{weight[i..n]},weight[i]}//确定需要枚举容量的下界  
    for v=V..bound  
        f[v]=max{f[v],f[v-weight[i]] + cost[i]}; 

原因:

1)网上的说法,不太懂,各位大牛可以指导下下。

对于第i次循环(指外循环),对于背包容量v = V(最大)时,对于f[v]的值,其实只要知道f[v-weight[i]]即可。以此类推,对于背包容量为 j 时,我们只需要知道到f[v-sum{weight[j..n]}]即可

2)还有人说

如果比v-sum{weight[j..n]}这个小,那么即使后面物品的全要也装不满背包。

所以对于物品i,小于v-sum{weight[j..n]}的v值,无意义。

总之是不懂。智商啊

作者说,当V很大是,效果好。

代码

#include <iostream>  
using namespace std;  
  
const int N = 3;//物品个数  
const int V = 5;//背包最大容量  
int weight[N + 1] = {0,3,2,2};//物品重量  
int value[N + 1] = {0,5,10,20};//物品价值  
  
int f[V + 1] = {0};  
  
int Max(int x,int y)  
{  
    return x > y ? x : y;  
}  
  
/* 
目标:在不超过背包容量的情况下,最多能获得多少价值 
 
子问题状态:f[j]:表示前i件物品放入容量为j的背包得到的最大价值 
 
状态转移方程:f[j] = max{f[j],f[j - weight[i]] + value[i]} 
 
初始化:f数组全设置为0 
*/  
int Knapsack()  
{  
    int sum = 0;//存储还未处理物品的总容量  
    int bound = 0;  
    //初始化  
    memset(f,0,sizeof(f));  
    for (int i = 1;i <= N;i++)  
    {  
        sum += weight[i];  
    }  
      
    //递推  
    for (int i = 1;i <= N;i++) //枚举物品  
    {  
        //设置下界  
        if (i != 1)  
        {  
            sum -= weight[i - 1];  
        }  
        bound = Max(V - sum,weight[i]);  
  
        for (int j = V;j >= bound;j--) //枚举背包容量  
        {  
            if (f[j] < f[j - weight[i]] + value[i])  
            {  
                f[j] = f[j - weight[i]] + value[i];  
            }  
        }  
    }  
    return f[V];  
}  
  
int main()  
{  
    cout<<Knapsack()<<endl;  
    system("pause");  
    return 1;  
}  


 输出方案

一般而言,背包问题是要求一个最优值,如果要求输出这个最优值的方案,可以参照一般动态规划问题输出方案的方法:记录下每个状态的最优值是由状态转移方程的哪一项推出来的,换句话说,记录下它是由哪一个策略推出来的。便可根据这条策略找到上一个状态,从上一个状态接着向前推即可。

这里我们首先给出01背包的二维状态转移方程

f[i][v] = max(f[i - 1][v],f[i - 1][v - weight[i]] + cost[i])  

对于状态f[i][v],它来自两种策略,可以是f[i - 1][v],也可以是f[i - 1][v - weight[i]] + cost[i]

其中,对于第二种情况,就是把物品i放入背包了,这里也是我们要找的情况

根据状态转移方程,我们可以给出两种实现方法

1) 借助存储状态的数组,直接根据状态转移方程倒着推,检测是否满足

f[i][v] == f[i - 1][v - weight[i]] + value[i]  

如果满足,则把第i件物品放入了,此时我们要检测第i - 1件物品,背包容量为v - weight[i]

不满足则表示没有把第i件物品放入,直接检测第i - 1件物品,此时背包容量还是v

注意,这种方法只适用于存储状态数组不压缩的情况。压缩数组由于数据有覆盖,不能使用

代码:

#include <iostream>  
using namespace std;  
  
const int N = 3;//物品个数  
const int V = 5;//背包最大容量  
int weight[N + 1] = {0,3,2,2};//物品重量  
int value[N + 1] = {0,5,10,20};//物品价值  
  
int f[N + 1][V + 1] = {{0}};  
  
int Max(int x,int y)  
{  
    return x > y ? x : y;  
}  
  
/* 
目标:在不超过背包容量的情况下,最多能获得多少价值 
 
子问题状态:f[i][j]:表示前i件物品放入容量为j的背包得到的最大价值 
 
状态转移方程:f[i][j] = max{f[i - 1][j],f[i - 1][j - weight[i]] + value[i]} 
 
初始化:f数组全设置为0 
*/  
int Knapsack()  
{  
    //初始化  
    memset(f,0,sizeof(f));  
    //递推  
    for (int i = 1;i <= N;i++) //枚举物品  
    {  
        for (int j = 1;j <= V;j++) //枚举背包容量  
        {  
            f[i][j] = f[i - 1][j];  
            if (j >= weight[i])  
            {  
                f[i][j] = Max(f[i - 1][j],f[i - 1][j - weight[i]] + value[i]);  
            }  
        }  
    }  
    return f[N][V];  
}  
/* 
输出顺序:逆序输出物品编号 
注意:这里借助状态数组f[i][v] 
使用状态转移方程:f[i][j] = max{f[i - 1][j],f[i - 1][j - weight[i]] + value[i]} 
*/  
void PrintKnapsack()  
{  
    int i = N;//枚举物品  
    int j = V;//枚举空间  
      
    cout<<"加入背包的物品编号:"<<endl;  
    while(i)  
    {  
        if (f[i][j] == f[i - 1][j - weight[i]] + value[i])  
        {  
            /*if不满足,表示第i件物品没装入背包, 
              if条件满足,表示放入背包了*/  
            cout<<i<<" ";  
            j -= weight[i];//此时容量减少  
        }  
        i--;  
    }  
    cout<<endl;  
}  
  
/* 
输出顺序:顺序输出物品编号 
注意:这里借助状态数组f[i][v] 
使用状态转移方程:f[i][j] = max{f[i - 1][j],f[i - 1][j - weight[i]] + value[i]} 
*/  
void PrintKnapsack_recursion(int i,int j)  
{  
    if (i == 0 || j == 0)  
    {  
        return;  
    }  
    if (f[i][j] == f[i - 1][j - weight[i]] + value[i])  
    {  
        PrintKnapsack_recursion(i - 1,j - weight[i]);  
        cout<<i<<" ";  
    }  
}  
  
int main()  
{  
    cout<<Knapsack()<<endl;  
    PrintKnapsack();  
    PrintKnapsack_recursion(N,V);  
    system("pause");  
    return 1;  
}  

2) 另外开辟数组,在求解最大收益时做标记位。求解完最大收益后,根据这个新数组倒着推结果

思想:对于现在这个状态的位置,它存储的是该状态上一位置

注意:这种方法均适用存储状态数组不压缩 和 压缩两种情况

代码:

#include <iostream>  
using namespace std;  
  
const int N = 3;//物品个数  
const int V = 5;//背包最大容量  
int weight[N + 1] = {0,3,2,2};//物品重量  
int value[N + 1] = {0,5,10,20};//物品价值  
  
int f[V + 1] = {0};  
  
int G[N + 1][V + 1] = {{0}};//求背包序列  
  
int Max(int x,int y)  
{  
    return x > y ? x : y;  
}  
  
/* 
目标:在不超过背包容量的情况下,最多能获得多少价值 
 
子问题状态:f[j]:表示前i件物品放入容量为j的背包得到的最大价值 
 
状态转移方程:f[j] = max{f[j],f[j - weight[i]] + value[i]} 
 
初始化:f数组全设置为0 
*/  
int Knapsack()  
{  
    //初始化  
    memset(f,0,sizeof(f));  
    memset(G,0,sizeof(G));  
    //递推  
    for (int i = 1;i <= N;i++) //枚举物品  
    {  
        for (int j = V;j >= weight[i];j--) //枚举背包容量  
        {  
            if (f[j] < f[j - weight[i]] + value[i])  
            {  
                f[j] = f[j - weight[i]] + value[i];  
                G[i][j] = 1;  
            }  
        }  
    }  
    return f[V];  
}  
/* 
输出顺序:逆序输出物品编号 
注意:这里另外开辟数组G[i][v],标记上一个状态的位置 
G[i][v] = 1:表示物品i放入背包了,上一状态为G[i - 1][v - weight[i]] 
G[i][v] = 0:表示物品i没有放入背包,上一状态为G[i - 1][v] 
*/  
void PrintKnapsack()  
{  
    int i = N;//枚举物品  
    int j = V;//枚举空间  
      
    cout<<"加入背包的物品编号:"<<endl;  
    while(i)  
    {  
        if (G[i][j] == 1)  
        {  
            /*if不满足,表示第i件物品没装入背包, 
              if条件满足,表示放入背包了*/  
            cout<<i<<" ";  
            j -= weight[i];//此时容量减少  
        }  
        i--;  
    }  
    cout<<endl;  
}  
  
/* 
输出顺序:顺序输出物品编号 
注意:这里另外开辟数组G[i][v],标记上一个状态的位置 
G[i][v] = 1:表示物品i放入背包了,上一状态为G[i - 1][v - weight[i]] 
G[i][v] = 0:表示物品i没有放入背包,上一状态为G[i - 1][v] 
*/  
void PrintKnapsack_recursion(int i,int j)  
{  
    if (i == 0 || j == 0)  
    {  
        return;  
    }  
    if (G[i][j] == 1)  
    {  
        PrintKnapsack_recursion(i - 1,j - weight[i]);  
        cout<<i<<" ";  
    }  
}  
  
int main()  
{  
    cout<<Knapsack()<<endl;  
    PrintKnapsack();  
    PrintKnapsack_recursion(N,V);  
    system("pause");  
    return 1;  
}  


小结:

01 背包问题是最基本的背包问题,它包含了背包问题中设计状态、方程的最基本思想。另外,别的类型的背包问题往往也可以转换成01 背包问题求解。故一定要仔细体会上面基本思路的得出方法,状态转移方程的意义,以及空间复杂度怎样被优化。




多重背包问题:

整理自背包问题九讲笔记_多重背包


1、问题描述

已知:有一个容量为V的背包和N件物品,第i件物品最多有Num[i]件,每件物品的重量是weight[i],收益是cost[i]。

问题:在不超过背包容量的情况下,最多能获得多少价值或收益

举例:物品个数N = 3,背包容量为V = 8,则背包可以装下的最大价值为64.


----------------------------------------------


2、转换为01背包问题求解(直接利用01背包)

思路 1、直接对每一件物品进行拆分成Num[i]件,之后在拆分后的集合上进行01背包的求解。

时间复杂度:O(V*Σ(Weight[i]))。太慢不好。

思路 2、采用二进制拆分的思想。对每i件物品,拆分的策略为:新拆分的物品的重量等于1件,2件,4件,..,(2^(k - 1)),Num[i] - (2^(k - 1))件,其中k 是满足Num[i] - 2^k + 1 > 0 的最大整数。

注意:

(1)最后一个物品的件数的求法和前面不同,其直接等于 该物品的最大件数 - 前面已经分配之和。

(2)分成的这几件物品的系数和为Num[i],表明第i种物品取的件数不能多于Num[i]。

举例:某物品为13件,则其可以分成四件物品,其系数为1,2,4,6.这里k = 3。

当然,这里使用二进制的前提还是使用二进制拆分能保证对于0,,,Num[i]间的每一个整数,均可以用若干个系数的和表示。

具体使用时,有一个小优化,即:

我们不对所有的物品进行拆分,因此物品一旦拆分,其物品个数肯定增加,那么复杂度肯定上去。

此时,我们可以选择性地对物品进行拆分:

(1)如果第i个物品的重量Weight[i] * 物品的个数Num[i] >= 背包总重量V,可以不用拆分。

(2)如果第i个物品的重量Weight[i] * 物品的个数Num[i] < 背包总重量V,需要拆分。

其实,拆不拆分,就看该物品能不能满足完全背包的条件。即,看该物品能不能无限量供应。

解释:为啥满足Weight[i] * 物品的个数Num[i] >= 背包总重量V的物品可以不用拆分?

此时,满足该条件时,此物品相当于是无限供应,直到背包放不下为止。

最终,对于不需要拆分的物品,可以看成完全背包的情况,调用处理完全背包物品的函数;对于需要拆分的物品,可以看成01背包的情况,调用处理01背包物品的函数。

这样,由于不对满足完全背包的物品进行拆分,此时物品个数就没有对所有物品拆分时的物品个数多,即程序中外层循环降低,复杂度也就下去了。

伪代码:


这里:C表示该物品的重量。M表示该物品的个数。V表示背包的最大容量。W表示该物品的收益。

多重背包问题代码:

#include <iostream>
using namespace std;

const int N = 1005;
int f[N + 1] = {0}; //初始化值
int weight[N + 1], value[N + 1], num[N + 1];
int V,n;
/*
01背包,v为降序
f[v]:表示把前i件物品放入容量为v的背包中获得的最大收益。
f[v] = max(f[v],f[v - Weight[i]] + Value[i]);
*/
void ZeroOnePack(int nWeight,int nValue)
{
    for (int v = V;v >= nWeight;v--)
    {
        f[v] = max(f[v],f[v - nWeight] + nValue);
    }
}
/*
完全背包,v为增序。
f[v]:表示把前i件物品放入容量为v的背包中获得的最大收益。
f[v] = max(f[v],f[v - Weight[i]] + Value[i]);
*/
void CompletePack(int nWeight,int nValue)
{
    for (int v = nWeight;v <= V;v++)
    {
        f[v] = max(f[v],f[v - nWeight] + nValue);
    }
}

int MultiplePack()
{
    int k = 1;
    int nCount = 0;
    for (int i = 1;i <= N;i++)
    {
        if (weight[i] * num[i] >= V)
        {
            //此时满足条件Weight[i] * Num[i] >= V时,
            //完全背包:该类物品相当于是无限供应,直到背包放不下为止。
            CompletePack(weight[i],value[i]);
        }
        else
        {
            k = 1;
            nCount = num[i];
            while(k <= nCount)
            {
                ZeroOnePack(k * weight[i],k * value[i]);
                nCount -= k;
                k *= 2;
            }
            ZeroOnePack(nCount * weight[i],nCount * value[i]);
        }
    }
    return f[V];
}

int main()
{
    int t,i;
	cin>>t;//会输入几组数据
	while(t--){
		cin>>V>>n;//v:背包容量 n:物体个数

		for(i = 1 ; i <= n; i++)//从i = 1开始输入!所以最后输出f[V]不是f[V-1]!
            cin>>weight[i]>>value[i]>>num[i];

        cout<<MultiplePack()<<endl;
	}
    return 1;
}



没有更多推荐了,返回首页