用蛮力法、动态规划法和贪心法求解0 1背包问题

合集下载

浅谈0-1背包问题的常用算法

浅谈0-1背包问题的常用算法
消 费 电子 Байду номын сангаас
2 0 1 3年 1 0月下 C o n s u me r E l e c t r o n i c s Ma g a z i n e 技 术 交 流
浅谈 0 - 1 背包问题的常用算法
汤赫 男
( 吉林工商学院信息工程学院,长春 1 3 0 0 6 2) 摘 要 :0 -1 背 包问题是典型的 NP ~完全问题 ,无论从 理论 上还是 实践上都有一定的研究意义。本文综述 了几 种0 — 1背包问题的 常用算法 ,分析算法的优劣 ,预 测 0 - 1背包问题的发展方向。 关键 词 :0 — 1背包问题 ;动 态规划法 ;贪心法 ;分支界限法


∑w ,
l {
㈠ { “ } m a x ∑
{ j
二 、常用 的 0 - 1 背 包问题算法 ( 一) 蛮力法。 蛮 力法又称穷举法或枚举法,是一种简单、 直接、有效的方法,是初学者入 门的方法 。蛮力法要求遍历所 有可能情 况一次且仅一次 ,筛选 出符合要求 的解。应用蛮力法 求解 0 - 1 背包 问题, 需要考虑给定的 n 个物品集合的所有子集, 找出所有总重量不超过背包容量的子集 ,计算每个可能子集的 总价值,然后找 出价值最大的子集 。对于一个具有 n个元素的 集合 ,其子集数量是 2 “,所 以,不论生成子集 的算法效率有 多高 ,蛮力法求解 0 - 1 背包 问题都会导致一个 Q ( 2 n )的算法 。 ( 二 )动 态规划法。动态规划 法是一种通用 的算 法设计 技术用来求解 多阶段决策最优 化问题。这类 问题都满 足最优 性原理,即原 问题 的最优 性包含着子 问题 的最优性 。 应用 动态规划法 求解 0 - 1 背包 问题 ,可 以将 0 — 1背包 问 题看 作一个 多阶段决策最 优化 问题 。n个物 品集合 的所 有子 集可 以看 作该 问题 的所有 可行解;这些可行解 都是满足约束 条件 的,可行解可能不止一个,通过 目标 函数找到最优解 。 动态 规划 法求解 0 - 1 背包 问题 的算法描述 : 设V ( n , C )表 示将 n个 物 品装入 容量 为 C的背 包获 得 的 最大价值 。 初 始 状 态 :V ( i , 0 ) = V ( 0 , j ) = 0 , 0≤ i ≤n , 0≤ j≤ C 则V ( i , j )表示 将前 i 个 物 品装入 容量 为 j的背 包获 得

动态规划-01背包问题

动态规划-01背包问题

动态规划——01背包问题01背包问题,是用来介绍动态规划算法最经典的例子,网上关于01背包问题的讲解也很多,我写这篇文章力争做到用最简单的方式,最少的公式把01背包问题讲解透彻。

01背包的状态转换方程 f[i,j] = Max{ f[i-1,j-Wi]+Pi( j >= Wi ), f[i-1,j] }f[i,j]表示在前i件物品中选择若干件放在承重为j 的背包中,可以取得的最大价值。

Pi表示第i件物品的价值。

决策:为了背包中物品总价值最大化,第i件物品应该放入背包中吗?题目描述:有编号分别为a,b,c,d,e的五件物品,它们的重量分别是2,2,6,5,4,它们的价值分别是6,3,5,4,6,现在给你个承重为10的背包,如何让背包里装入的物品具有最大的价值总和?只要你能通过找规律手工填写出上面这张表就算理解了01背包的动态规划算法。

首先要明确这张表是至底向上,从左到右生成的。

为了叙述方便,用e2单元格表示e行2列的单元格,这个单元格的意义是用来表示只有物品e 时,有个承重为2的背包,那么这个背包的最大价值是0,因为e物品的重量是4,背包装不了。

对于d2单元格,表示只有物品e,d时,承重为2的背包,所能装入的最大价值,仍然是0,因为物品e,d都不是这个背包能装的。

同理,c2=0,b2=3,a2=6。

对于承重为8的背包,a8=15,是怎么得出的呢?根据01背包的状态转换方程,需要考察两个值,一个是f[i-1,j],对于这个例子来说就是b8的值9,另一个是f[i-1,j-Wi]+Pi;在这里, f[i-1,j]表示我有一个承重为8的背包,当只有物品b,c,d,e四件可选时,这个背包能装入的最大价值f[i-1,j-Wi]表示我有一个承重为6的背包(等于当前背包承重减去物品a的重量),当只有物品b,c,d,e四件可选时,这个背包能装入的最大价值f[i-1,j-Wi]就是指单元格b6,值为9,Pi指的是a物品的价值,即6由于f[i-1,j-Wi]+Pi = 9 + 6 = 15 大于f[i-1,j] = 9,所以物品a应该放入承重为8的背包以下是actionscript3 的代码[java]view plain copy1.public function get01PackageAnswer(bagItems:Array,bagSize:int):Array2.{3. var bagMatrix:Array=[];4. var i:int;5. var item:PackageItem;6.for(i=0;i<bagItems.length;i++)7. {8. bagMatrix[i] = [0];9. }10.for(i=1;i<=bagSize;i++)11. {12.for(var j:int=0;j<bagItems.length;j++)13. {14. item = bagItems[j] as PackageItem;15.if(item.weight > i)16. {17.//i背包转不下item18.if(j==0)19. {20. bagMatrix[j][i] = 0;21. }22.else23. {24. bagMatrix[j][i]=bagMatrix[j-1][i];25. }26. }27.else28. {29.//将item装入背包后的价值总和30. var itemInBag:int;31.if(j==0)32. {33. bagMatrix[j][i] = item.value;34.continue;35. }36.else37. {38. itemInBag = bagMatrix[j-1][i-item.weight]+item.value;39. }40. bagMatrix[j][i] = (bagMatrix[j-1][i] > itemInBag ? bagMatrix[j-1][i] : itemInBag)41. }42. }43. }44.//find answer45. var answers:Array=[];46. var curSize:int = bagSize;47.for(i=bagItems.length-1;i>=0;i--)48. {49. item = bagItems[i] as PackageItem;50.if(curSize==0)51. {52.break;53. }54.if(i==0 && curSize > 0)55. {56. answers.push();57.break;58. }59.if(bagMatrix[i][curSize]-bagMatrix[i-1][curSize-item.weight]==item.value)60. {61. answers.push();62. curSize -= item.weight;63. }64. }65.return answers;66.}PackageItem类[java]view plain copy1.public class PackageItem2.{3.public var name:String;4.public var weight:int;5.public var value:int;6.public function PackageItem(name:String,weight:int,value:int)7. { = name;9.this.weight = weight;10.this.value = value;11. }12.}测试代码[java]view plain copy1.var nameArr:Array=['a','b','c','d','e'];2.var weightArr:Array=[2,2,6,5,4];3.var valueArr:Array=[6,3,5,4,6];4.var bagItems:Array=[];5.for(var i:int=0;i<nameArr.length;i++)6.{7. var bagItem:PackageItem = new PackageItem(nameArr[i],weightArr[i],valueArr[i]);8. bagItems[i]=bagItem;9.}10.var arr:Array = ac.get01PackageAnswer(bagItems,10);出师表两汉:诸葛亮先帝创业未半而中道崩殂,今天下三分,益州疲弊,此诚危急存亡之秋也。

利用动态规划解决01背包问题01背包问题动态规划

利用动态规划解决01背包问题01背包问题动态规划

利用动态规划解决01背包问题01背包问题动态规划背包问题是一个经典的动态规划模型,很多关于算法的教材都把它作为一道例题,该问题既简单又容易理解,而且在某种程度上还能够揭示动态规划的本质。

将具有不同重量和价值的物体装入一个有固定载重量的背包,以获取最大价值,这类问题被称为背包问题。

背包问题可以扩展出很多种问题,而01背包问题是最常见、最有代表性的背包问题。

一、问题描述给定一个载重量为M的背包及n个物体,物体i的重量为wi、价值为pi,1≤i≤n,要求把这些物体装入背包,使背包内的物体价值总量最大。

此处我们讨论的物体是不可分割的,通常称这种物体不可分割的背包问题为01背包问题。

二、基本思路01背包问题的特点是:每种物体只有一件,可以选择放或者不放。

假设:xi表示物体i被装入背包的情况,xi=0,1。

当xi=0时,表示物体没有被装入背包;当xi=1时,表示物体被装入背包。

根据问题的要求,有如下的约束方程(1)和目标函数(2):三、利用动态规划法求解01背包问题(一)动态规划算法的基本思想动态规划算法通常用于求解具有某种最优性质的问题。

在这类问题中,可能会有许多可行解。

每一个解都对应于一个值,我们希望找到具有最优值的解。

动态规划算法与分治法类似,其基本思想也是将待求解问题分解成若干个子问题,先求解子问题,然后从这些子问题的解得到原问题的解。

与分治法不同的是,适合于用动态规划求解的问题,经分解得到子问题往往不是互相独立的。

若用分治法来解这类问题,则分解得到的子问题数目太多,有些子问题被重复计算很多次。

如果我们能够保存已解决的子问题的答案,而在需要时再找出已求得的答案,这样就可以避免大量的重复计算,节省时间。

我们可以用一个表来记录所有已解的子问题的答案。

不管该子问题以后是否被用到,只要它被计算过,就将其结果填入表中,这就是动态规划法的基本思路。

具体的动态规划算法多种多样,但它们具有相同的填表格式。

(二)算法设计假定背包的载重量范围为0~m。

蛮力法、动态规划法 求解01背包问题

蛮力法、动态规划法 求解01背包问题
v[i][j]=values[i]+v[i-1][j-weigths[i]];
else
v[i][j]=v[i-1][j];
}
else v[i][j]=v[i-1][j];
}
return v[n][m];
}
int main()
{
int m,n;int i,j;
cout<<"请输入背包的承重量:"<<endl;
2)复杂度分析:2n
2、动态规划法
1)基本思想:Dynamic programming is a technique for solving problems with overlapping subproblems.The function:
V(i,0)=V(0,j)=0;(1)
V(i-1,j)j<w
if (cur_weight <= capacity && cur_value > max_value) {
max_value = cur_value;
}
return;
}
c[d] = 0;
MFKnapsack(capacity, values, weights, c,
d + 1, max_value);
cout << MFKnapsack(capacity, values, weights, n) << endl;
return 0;
}
(2)Dynamic Programming
#include<iostream.h>
#include<string.h>
int v[10][100];//对应每种情况的最大价值

实验项目三 用蛮力法、动态规划法和贪心法求解背包问题

实验项目三  用蛮力法、动态规划法和贪心法求解背包问题

实验项目三 用蛮力法、动态规划法和贪心法求解0/1背包问题实验目的1、学会背包的数据结构的设计,针对不同的问题涉及到的对象的数据结构的设计也不同;2、对0-1背包问题的算法设计策略对比与分析。

实验内容:0/1背包问题是给定n 个重量为{w 1, w 2, … ,wn }、价值为{v 1, v 2, … ,vn }的物品和一个容量为C 的背包,求这些物品中的一个最有价值的子集,并且要能够装到背包中。

在0/1背包问题中,物品i 或者被装入背包,或者不被装入背包,设xi 表示物品i 装入背包的情况,则当xi =0时,表示物品i 没有被装入背包,xi =1时,表示物品i 被装入背包。

根据问题的要求,有如下约束条件和目标函数:于是,问题归结为寻找一个满足约束条件式1,并使目标函数式2达到最大的解向量X =(x 1, x 2, …, xn )。

背包的数据结构的设计:typedef struct object{int n;//物品的编号int w;//物品的重量int v;//物品的价值}wup;wup wp[N];//物品的数组,N 为物品的个数int c;//背包的总重量1、蛮力法蛮力法是一种简单直接的解决问题的方法,常常直接基于问题的描述和所涉及的概念定义。

蛮力法的关键是依次处理所有的元素。

用蛮力法解决0/1背包问题,需要考虑给定n 个物品集合的所有子集,找出所有可能的子集(总重量不超过背包容量的子集),计算每个子集的总价值,然后在他们中找到价值最大的子集。

所以蛮力法解0/1背包问题的关键是如何求n 个物品集合的所有子集,n 个物品的子集有2的n 次方个,用一个2的n 次方行n 列的数组保存生成的子集,以下是生成子集的算法:⎪⎩⎪⎨⎧≤≤∈≤∑=)1(}1,0{1n i x C x w i n i i i (式1)∑=ni i i x v 1max (式2)void force(int a[16][4])//蛮力法产生4个物品的子集{int i,j;int n=16;int m,t;for(i=0;i<16;i++){ t=i;for(j=3;j>=0;j--){m=t%2;a[i][j]=m;t=t/2;}}for(i=0;i<16;i++)//输出保存子集的二维数组{for(j=0;j<4;j++){printf("%d ",a[i][j]);}printf("\n");}}以下要依次判断每个子集的可行性,找出可行解:void panduan(int a[][4],int cw[])////判断每个子集的可行性,如果可行则计算其价值存入数组cw,不可行则存入0{int i,j;int n=16;int sw,sv;for(i=0;i<16;i++){sw=0;sv=0;for(j=0;j<4;j++){sw=sw+wp[j].w*a[i][j];sv=sv+wp[j].v*a[i][j];}if(sw<=c)cw[i]=sv;elsecw[i]=0;}在可行解中找出最优解,即找出可行解中满足目标函数的最优解。

c语言算法--贪婪算法---01背包问题

c语言算法--贪婪算法---01背包问题

c语言算法--贪婪算法---0/1背包问题在0 / 1背包问题中,需对容量为c 的背包进行装载。

从n 个物品中选取装入背包的物品,每件物品i 的重量为wi ,价值为pi 。

对于可行的背包装载,背包中物品的总重量不能超过背包的容量,最佳装载是指所装入的物品价值最高,即n ?i=1pi xi 取得最大值。

约束条件为n ?i =1wi xi≤c 和xi?[ 0 , 1 ] ( 1≤i≤n)。

在这个表达式中,需求出xt 的值。

xi = 1表示物品i 装入背包中,xi =0 表示物品i 不装入背包。

0 / 1背包问题是一个一般化的货箱装载问题,即每个货箱所获得的价值不同。

货箱装载问题转化为背包问题的形式为:船作为背包,货箱作为可装入背包的物品。

例1-8 在杂货店比赛中你获得了第一名,奖品是一车免费杂货。

店中有n 种不同的货物。

规则规定从每种货物中最多只能拿一件,车子的容量为c,物品i 需占用wi 的空间,价值为pi 。

你的目标是使车中装载的物品价值最大。

当然,所装货物不能超过车的容量,且同一种物品不得拿走多件。

这个问题可仿照0 / 1背包问题进行建模,其中车对应于背包,货物对应于物品。

0 / 1背包问题有好几种贪婪策略,每个贪婪策略都采用多步过程来完成背包的装入。

在每一步过程中利用贪婪准则选择一个物品装入背包。

一种贪婪准则为:从剩余的物品中,选出可以装入背包的价值最大的物品,利用这种规则,价值最大的物品首先被装入(假设有足够容量),然后是下一个价值最大的物品,如此继续下去。

这种策略不能保证得到最优解。

例如,考虑n=2, w=[100,10,10], p =[20,15,15], c = 1 0 5。

当利用价值贪婪准则时,获得的解为x= [ 1 , 0 , 0 ],这种方案的总价值为2 0。

而最优解为[ 0 , 1 , 1 ],其总价值为3 0。

另一种方案是重量贪婪准则是:从剩下的物品中选择可装入背包的重量最小的物品。

动态规划算法-01背包问题

动态规划算法-01背包问题
intm = 17;//背包容量
intn = 5;//物品个数
//c[i][j]表示前i个物品能装入容量为Wj的背包中的最大价值
intc[][] =newint[n+1][m+1];
intpath[][] =newint[n+1][m+1];
//初始化第一列和第一行
for(inti=0;i<c.length;i++){
动态规划算法是非常有效的算法技术,那么什么时候使用它呢?或者说其运用场景是什么?若求解问题具有一下性质,可以考虑使用动态规划法:
1、最优子结构:如果一个问题的最优解中包含其子问题的最优解,就是说该问题具有最优子结构。这时候贪婪算法可能也使用求解此类问题
2、重叠子问题:重叠子问题是指用来求解问题的递归算法可以反复的解同样的问题,而不是总在产生新的问题,即当一个递归算法不断的调用同一个问题时,就说该问题包含重叠子问题,此时若使用分治法递归求解时,则每次遇到子问题都会视为新问题,会极大降低效率,而动态规划法对每个子问题仅计算一次,把解保存到在一个需要时就可以查看的表中
根据上述分析,设c[i , w]表示背包容量为w时i个物品最优解的总价值,得到公式:
0i = 0或w = 0
C[i , w ] =c[i – 1, w] wi > w
max{ c[i–1 ,w–wi ] + vi , c[i – 1,w]} i > 0且wi <= w
2、根据物品的件数i = 5、包的容量W = 17规划“价值”分布矩阵,如下图所示:
{
int i,w;
//为二维数组申请空间
int** c = (int**)malloc(sizeof(int *)*(n+1));

用动态规划法求解01背包问题

用动态规划法求解01背包问题

用动态规划法求解0/1背包问题实验目的:1、掌握动态规划算法求解问题的一般特征和步骤。

2、使用动态规划法编程,求解0/1背包问题。

实验要求:1、掌握动态规划算法求解问题的一般特征和步骤。

2、使用动态规划法编程,求解0/1背包问题。

实验内容:1、问题描述:给定n种物品和一个背包,物品I的重量是Wi,其价值为Vi,问如何选择装入背包的物品,使得装入背包的物品的总价值最大?2、算法描述。

3、程序实现给出实例测试结果。

程序清单:#include<iostream>#include<iomanip>using namespace std;int c[50][50];int w[10],v[10];int x[10];int n;void KNAPSACK_DP(int n,int W){for(int k=0;k<=W;k++)c[0][k]=0;for(int i=1;i<=n;i++){c[i][0]=0;for(int k=1;k<=W;k++){if(w[i]<=k){if(v[i]+c[i-1][k-w[i]]>c[i-1][k])c[i][k]=v[i]+c[i-1][k-w[i]];elsec[i][k]=c[i-1][k];}elsec[i][k]=c[i-1][k];}}}void OUTPUT_SACK(int c[50][50],int k) {for(int i=n;i>=2;i--){if(c[i][k]==c[i-1][k])x[i]=0;else{x[i]=1;k=k-w[i];}}x[1]=(c[1][k]?1:0);for(int i=1;i<=n;i++)cout<<setw(4)<<x[i];}void main(){int m;cout<<"输入物品个数:";cin>>n;cout<<"依次输入物品的重量:"<<endl; for(int i=1;i<=n;i++)cin>>w[i];cout<<"依次输入物品的价值:"<<endl; for(int i=1;i<=n;i++)cin>>v[i];cout<<"输入背包最大容量:";cin>>m;for(int i=1;i<=m;i++)cout<<setw(4)<<i;cout<<endl;KNAPSACK_DP(n,m);cout<<"构造最优解过程如下:"<<endl; for(int j=1;j<=5;j++){for(int k=1;k<=m;k++)cout<<setw(4)<<c[j][k];cout<<endl;}cout<<"最优解为:"<<endl;OUTPUT_SACK(c,m);}运行结果:输入物品个数:5依次输入物品的重量:3 4 7 8 9依次输入物品的价值:4 5 10 11 13输入背包最大容量:171 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 构造最优解过程如下:0 0 4 4 4 4 4 4 4 4 4 4 4 4 4 4 40 0 4 5 5 5 9 9 9 9 9 9 9 9 9 9 90 0 4 5 5 5 10 10 10 14 15 15 15 19 19 19 19 0 0 4 5 5 5 10 11 11 14 15 16 16 19 21 21 21 0 0 4 5 5 5 10 11 13 14 15 17 18 19 21 23 24 最优解为:0 0 0 1 1实验体会:通过该实验,使用动态规划法编程,求解0/1背包问题,掌握动态规划算法求解问题的一般特征和步骤。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
printf("\n");
}

以下要依次判断每个子集的可行性,找出可行解:
voidpanduan(inta[][4],intcw[])////判断每个子集的可行性,如果可行则计算其价值存入数组cw,不可行则存入0
{
int i,j;
int n=16;
int sw,sv;
for(i=0;i<16;i++)
用蛮力法解决0/1背包问题,需要考虑给定n个物品集合的所有子集,找出所有可能的子集(总重量不超过背包容量的子集),计算每个子集的总价值,然后在他们中找到价值最大的子集。
所以蛮力法解0/1背包问题的关键是如何求n个物品集合的所有子集,n个物品的子集有2的n次方个,用一个2的n次方行n列的数组保存生成的子集,以下是生成子集的算法:void force(int a[][4])//蛮力法产生4个物品的子集
{
int i,j;
int n=16;
int m,t;
for(i=0;i<16;i++)
{t=i;
for(j=3;j>=0;j--)
{
m=t%2;
a[i][j]=m;
t=t/2;
}
}
for(i=0;i<16;i++)//输出保存子集的二维数组
{
for(j=0;j<4;j++)
{
printf("%d",a[i][j]);
i++;
}
return maxprice;
}
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define C 10//定义背包总重量为10
#define N 4//定义物品个数为4
typedef struct object//背包的数据结构的设计
实验目的
1、学会背包的数据结构的设计,针对不同的问题涉及到的对象的数据结构的设计也不同;
2、对0-1背包问题的算法设计策略对比与分析。
实验内容:
0/1背包问题是给定n个重量为{w1,w2, …,wn}、价值为{v1,v2, …,vn}的物品和一个容量为C的背包,求这些物品中的一个最有价值的子集,并且要能够装到背包中。
以下是动态规划法求解背包问题的算法:
int findmaxvalue(wup *p,int x[])//x数组用来存放可行解,p是指向存放物品数组的指针{
int i,j;
int maxvalue;
int value[N+1][C+1];
for(j=0;j<=C;j++)
value[0][j]=0; //初始化第0行
贪心法求解的问题的特征:
(1)最优子结构性质
当一个问题的最优解包含其子问题的最优解时,称此问题具有最优子结构性质,也称此问题满足最优性原理。
(2)贪心选择性质
所谓贪心选择性质是指问题的整体最优解可以通过一系列局部最优的选择,即贪心选择来得到。
用贪心法求解问题应该考虑如下几个方面:
(1)候选集合C:为了构造问题的解决方案,有一个候选集合C作为问题的可能解,即问题的最终解均取自于候选集合C。例如,在付款问题中,各种面值的货币构成候选集合。
{
int n;//物品的编号
int w;//物品的重量
int v;//物品的价值
}wup;
wupwp[N];//物品的数组,N为物品的个数
void inputwp(wup*p)//输入函数
{
int i;//i为物品的个数
for (i=0;i<N;i++)//for循环物品的个数,总的物品有N个
{
printf("\n请输入第%d个物品的编号、重量、价值",i);
动态规划法将待求解问题分解成若干个相互重叠的子问题,每个子问题对应决策过程的一个阶段,一般来说,子问题的重叠关系表现在对给定问题求解的递推关系(也就是动态规划函数)中,将子问题的解求解一次并填入表中,当需要再次求解此子问题时,可以通过查表获得该子问题的解而不用再次求解,从而避免了大量重复计算。
动态规划法设计算法一般分成三个阶段:
V(i, 0)=V(0,j)=0(式3)jw
V(i1,j)
V(i,j)
i(式4)max{V(i1,j),V(i1,jw
i)v
i}jw
i
式3表明:把前面i个物品装入容量为0的背包和把0个物品装入容量为j的背包,得到的价值均为0。式4的第一个式子表明:如果第i个物品的重量大于背包的容量,则装入前i个物品得到的最大价值和装入前i-1个物品得到的最大价值是相同的,即物品i不能装入背包;第二个式子表明:如果第i个物品的重量小于背包的容量,则会有以下两种情况:(1)如果把第i个物品装入背包,则背包中物品的价值等于把前i-1个物品装入容量为j-wi的背包中的价值加上第i个物品的价值vi;(2)如果第i个物品没有装入背包,则背包中物品的价值就等于把前i-1个物品装入容量为j的背包中所取得的价值。显然,取二者中价值较大者作为把前i个物品装入容量为j的背包中的最优解。
在0/1背包问题中,物品i或者被装入背包,或者不被装入背包,设xi表示物品i装入背包的情况,则当xi=0时,表示物品i没有被装入背包,xi=1时,表示物品i被装入背包。
根据问题的要求,有如下约束条件和目标函数:
n
w
ix
iC
i1
x
i{0,1}(1in)(式1)
(式2)maxv源自ixii1
n
于是,问题归结为寻找一个满足约束条件式1,并使目标函数式2达到最大的解向量X=(x1,x2, …,xn)。
return maxvalue;
}
3、贪心法
贪心法在解决问题的策略上目光短浅,只根据当前已有的信息就做出选择,而且一旦做出了选择,不管将来有什么结果,这个选择都不会改变。换言之,贪心法并不是从整体最优考虑,它所做出的选择只是在某种意义上的局部最优。
这种局部最优选择并不总能获得整体最优解(Optimal Solution),但通常能获得近似最优解(Near-Optimal Solution)。
scanf("%d",&p->n);//输入物品的编号
scanf("%d",&p->w);//输入物品的重量
scanf("%d",&p->v);//输入物品的价值
p=p+1;//p为一个指针,指向下一个物品
}
printf("\n");//输出结果
}
void ontputwp(wup*p)//输出函数
(2)选择重量最轻的物品,因为这可以装入尽可能多的物品,从而增加背包的总价值。但是,虽然每一步选择使背包的容量消耗得慢了,但背包的价值却没能保证迅速增长,从而不能保证目标函数达到最大。
(3)选择单位重量价值最大的物品,在背包价值增长和背包容量消耗两者之间寻找平衡。
应用第三种贪心策略,每次从物品集合中选择单位重量价值最大的物品,如果其重量小于背包容量,就可以把它装入,并将背包容量减去该物品的重量,然后我们就面临了一个最优子问题——它同样是背包问题,只不过背包容量减少了,物品集合减少了。因此背包问题具有最优子结构性质。
(1)分段:将原问题分解为若干个相互重叠的子问题;
(2)分析:分析问题是否满足最优性原理,找出动态规划函数的递推式;
(3)求解:利用递推式自底向上计算,实现动态规划过程。
0/1背包问题可以看作是决策一个序列(x1,x2, …,xn),对任一变量xi的决策是决定xi=1还是xi=0。在对xi-1决策后,已确定了(x1, …,xi-1),在决策xi时,问题处于下列两种状态之一:
(1)背包容量不足以装入物品i,则xi=0,背包不增加价值;
(2)背包容量可以装入物品i,则xi=1,背包的价值增加了vi。
这两种情况下背包价值的最大者应该是对xi决策后的背包价值。令V(i, j)表示在前i(1≤i≤n)个物品中能够装入容量为j(1≤j≤C)的背包中的物品的最大值,则可以得到如下动态规划函数:
for(i=0;i<=N;i++)
value[i][0]=0;//初始化第0列
//计算数组value中各元素的值
for(i=1;i<=N;i++,p++)
for(j=1;j<=C;j++)
{
if(p->w >j)
{
value[i][j]=value[i-1][j];
}
else
{
value[i][j]=max(value[i-1][j],(value[i-1][j-p->w]+p->v));//max函数求两个数当中的大者
x[i] = 0;
i = 0;
maxprice=0;
while (i < n && w[i] < M)
{
M=M-w[i];
x[i] =w[i]; /*表示放入数量*/
maxprice=maxprice+p[i];
x[n-1]=M;
i++;
}
if (i < n &&M> 0)
{
maxprice=maxprice+p[i]*x[i]/w[i];
(2)解集合S:随着贪心选择的进行,解集合S不断扩展,直到构成一个满足问题的完整解。例如,在付款问题中,已付出的货币构成解集合。
相关文档
最新文档