01背包问题(动态规划法)
动态规划与回溯法解决0-1背包问题

0-1背包动态规划解决问题一、问题描述:有n个物品,它们有各自的重量和价值,现有给定容量的背包,如何让背包里装入的物品具有最大的价值总和?二、总体思路:根据动态规划解题步骤(问题抽象化、建立模型、寻找约束条件、判断是否满足最优性原理、找大问题与小问题的递推关系式、填表、寻找解组成)找出01背包问题的最优解以及解组成,然后编写代码实现。
原理:动态规划与分治法类似,都是把大问题拆分成小问题,通过寻找大问题与小问题的递推关系,解决一个个小问题,最终达到解决原问题的效果。
但不同的是,分治法在子问题和子子问题等上被重复计算了很多次,而动态规划则具有记忆性,通过填写表把所有已经解决的子问题答案纪录下来,在新问题里需要用到的子问题可以直接提取,避免了重复计算,从而节约了时间,所以在问题满足最优性原理之后,用动态规划解决问题的核心就在于填表,表填写完毕,最优解也就找到。
过程:a) 把背包问题抽象化(X1,X2,…,Xn,其中 Xi 取0或1,表示第i 个物品选或不选),V i表示第i 个物品的价值,W i表示第i 个物品的体积(重量);b) 建立模型,即求max(V1X1+V2X2+…+VnXn);c) 约束条件,W1X1+W2X2+…+WnXn<capacity;d) 定义V(i,j):当前背包容量j,前i 个物品最佳组合对应的价值;e) 最优性原理是动态规划的基础,最优性原理是指“多阶段决策过程的最优决策序列具有这样的性质:不论初始状态和初始决策如何,对于前面决策所造成的某一状态而言,其后各阶段的决策序列必须构成最优策略”。
判断该问题是否满足最优性原理,采用反证法证明:假设(X1,X2,…,Xn)是01背包问题的最优解,则有(X2,X3,…,Xn)是其子问题的最优解,假设(Y2,Y3,…,Yn)是上述问题的子问题最优解,则理应有(V2Y2+V3Y3+…+V n Yn)+V1X1 > (V2X2+V3X3+…+VnXn)+V1X1;而(V2X2+V3X3+…+VnXn)+V1X1=(V1X1+V2X2+…+VnXn),则有(V2Y2+V3Y3+…+VnYn)+V1X1 > (V1X1+V2X2+…+VnXn);该式子说明(X1,Y2,Y3,…,Yn)才是该01背包问题的最优解,这与最开始的假设(X1,X2,…,Xn)是01背包问题的最优解相矛盾,故01背包问题满足最优性原理;f) 寻找递推关系式,面对当前商品有两种可能性:第一,包的容量比该商品体积小,装不下,此时的价值与前i-1个的价值是一样的,即V(i,j)=V(i-1,j);第二,还有足够的容量可以装该商品,但装了也不一定达到当前最优价值,所以在装与不装之间选择最优的一个,即V(i,j)=max{V(i-1,j),V(i-1,j-w(i))+v(i) }其中V(i-1,j)表示不装,V(i-1,j-w(i))+v(i) 表示装了第i个商品,背包容量减少w(i)但价值增加了v(i);由此可以得出递推关系式:1) j<w(i) V(i,j)=V(i-1,j)2) j>=w(i) V(i,j)=max{ V(i-1,j),V(i-1,j-w(i))+v(i) }number=4,capacity=7四、构造最优解:最优解的构造可根据C列的数据来构造最优解,构造时从第一个物品开始。
动态规划之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的背包,如何让背包里装入的物品具有最首先要明确这张表是从右到左,至底向上生成的。
为了叙述方便,用e10单元格表示e行10列的单元格,这个单元格的意义是用来表示只有物品e时,有个承重为10的背包,那么这个背包的最大价值是6,因为e物品的重量是4,背包装的了,把e装进去后价值为6。
然后是e9单元格表示背包承重9,只有物品e, e装进去后,背包价值为6,接着是e8, e7单元格,一直到e3单元格表示背包承重3,但物品e承重4,装不了,所以e3=0,对于d10单元格,表示只有物品e,d时,承重为10的背包,所能装入的最大价值,是10,因为物品e,d这个背包都能装进去。
对于承重为9的背包,d9=10,是怎么得出的呢?根据01背包的状态转换方程,需要考察两个值,一个是f[i-1,j],对于这个例子来说就是e9的值6,另一个是f[i-1,j-Wi]+Pi;在这里,f[i-1,j]表示我有一个承重为9的背包,当只有物品e可选时,这个背包能装入的最大价值f[i-1,j-Wi]表示我有一个承重为4的背包(等于当前背包承重减去物品d的重量),当只有物品e可选时,这个背包能装入的最大价值f[i-1,j-Wi]就是指单元格e4值为6,Pi指的是d物品的价值,即4由于f[i-1,j-Wi]+Pi = 6 + 4 = 10 大于f[i-1,j] = 6,所以物品d应该放入承重为9的背包,所以d9=10.。
动态规划——01背包问题

动态规划——01背包问题⼀、最基础的动态规划之⼀01背包问题是动态规划中最基础的问题之⼀,它的解法完美地体现了动态规划的思想和性质。
01背包问题最常见的问题形式是:给定n件物品的体积和价值,将他们尽可能地放⼊⼀个体积固定的背包,最⼤的价值可以是多少。
我们可以⽤费⽤c和价值v来描述⼀件物品,再设允许的最⼤花费为w。
只要n稍⼤,我们就不可能通过搜索来遍查所有组合的可能。
运⽤动态规划的思想,我们把原来的问题拆分为⼦问题,⼦问题再进⼀步拆分直⾄不可再分(初始值),随后从初始值开始,尽可能地求取每⼀个⼦问题的最优解,最终就能求得原问题的解。
由于不同的问题可能有相同的⼦问题,⼦问题存在⼤量重叠,我们需要额外的空间来存储已经求得的⼦问题的最优解。
这样,可以⼤幅度地降低时间复杂度。
有了这样的思想,我们来看01背包问题可以怎样拆分成⼦问题:要求解的问题是:在n件物品中最⼤花费为w能得到的最⼤价值。
显然,对于0 <= i <= n,0 <= j <= w,在前i件物品中最⼤花费为j能得到的最⼤价值。
可以使⽤数组dp[n + 1][w + 1]来存储所有的⼦问题,dp[i][j]就代表从前i件物品中选出总花费不超过j时的最⼤价值。
可知dp[0][j]值⼀定为零。
那么,该怎么递推求取所有⼦问题的解呢。
显⽽易见,要考虑在前i件物品中拿取,⾸先要考虑前i - 1件物品中拿取的最优情况。
当我们从第i - 1件物品递推到第i件时,我们就要考虑这件物品是拿,还是不拿,怎样收益最⼤。
①:⾸先,如果j < c[i],那第i件物品是⽆论如何拿不了的,dp[i][j] = dp[i - 1][j];②:如果可以拿,那就要考虑拿了之后收益是否更⼤。
拿这件物品需要花费c[i],除去这c[i]的⼦问题应该是dp[i - 1][j - c[i]],这时,就要⽐较dp[i - 1][j]和dp[i - 1][j - c[i]] + v[i],得出最优⽅案。
动态规划——背包问题python实现(01背包、完全背包、多重背包)

动态规划——背包问题python实现(01背包、完全背包、多重背包)参考:⽬录描述:有N件物品和⼀个容量为V的背包。
第i件物品的体积是vi,价值是wi。
求解将哪些物品装⼊背包,可使这些物品的总体积不超过背包流量,且总价值最⼤。
⼆维动态规划f[i][j] 表⽰只看前i个物品,总体积是j的情况下,总价值最⼤是多少。
result = max(f[n][0~V]) f[i][j]:不选第i个物品:f[i][j] = f[i-1][j];选第i个物品:f[i][j] = f[i-1][j-v[i]] + w[i](v[i]是第i个物品的体积)两者之间取最⼤。
初始化:f[0][0] = 0 (啥都不选的情况,不管容量是多少,都是0?)代码如下:n, v = map(int, input().split())goods = []for i in range(n):goods.append([int(i) for i in input().split()])# 初始化,先全部赋值为0,这样⾄少体积为0或者不选任何物品的时候是满⾜要求dp = [[0 for i in range(v+1)] for j in range(n+1)]for i in range(1, n+1):for j in range(1,v+1):dp[i][j] = dp[i-1][j] # 第i个物品不选if j>=goods[i-1][0]:# 判断背包容量是不是⼤于第i件物品的体积# 在选和不选的情况中选出最⼤值dp[i][j] = max(dp[i][j], dp[i-1][j-goods[i-1][0]]+goods[i-1][1])print(dp[-1][-1])⼀维动态优化从上⾯⼆维的情况来看,f[i] 只与f[i-1]相关,因此只⽤使⽤⼀个⼀维数组[0~v]来存储前⼀个状态。
那么如何来实现呢?第⼀个问题:状态转移假设dp数组存储了上⼀个状态,那么应该有:dp[i] = max(dp[i] , dp[i-v[i]]+w[i])max函数⾥⾯的dp[i]代表的是上⼀个状态的值。
分支界限方法01背包问题解题步骤

分支界限方法是一种用于解决优化问题的算法。
在动态规划算法中,分支界限方法被广泛应用于解决01背包问题。
01背包问题是一个经典的动态规划问题,其解题步骤如下:1. 确定问题:首先需要明确01背包问题的具体描述,即给定一组物品和一个背包,每个物品有自己的价值和重量,要求在不超过背包容量的情况下,选取尽可能多的物品放入背包,使得背包中物品的总价值最大。
2. 列出状态转移方程:对于01背包问题,可以通过列出状态转移方程来描述问题的求解过程。
假设dp[i][j]表示在前i个物品中,背包容量为j时能够获得的最大价值,则状态转移方程可以表示为:dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+v[i])3. 初始化边界条件:在动态规划中,需要对状态转移方程进行初始化,一般情况下,dp数组的第一行和第一列需要单独处理。
对于01背包问题,可以初始化dp数组的第一行和第一列为0。
4. 利用分支界限方法优化:针对01背包问题,可以使用分支界限方法来优化动态规划算法的效率。
分支界限方法采用广度优先搜索的思想,在每一步选择最有希望的分支,从而减少搜索空间,提高算法的效率。
5. 实际解题步骤:根据上述步骤,实际解决01背包问题的步骤可以概括为:确定问题,列出状态转移方程,初始化边界条件,利用分支界限方法优化,最终得到问题的最优解。
分支界限方法在解决01背包问题时起到了重要的作用,通过合理的剪枝策略,可以有效地减少动态规划算法的时间复杂度,提高问题的求解效率。
分支界限方法也可以应用于其他优化问题的求解过程中,在算法设计和实现中具有重要的理论和实际意义。
在实际应用中,分支界限方法需要根据具体问题进行灵活选择和调整,结合动态规划和剪枝策略,以便更好地解决各类优化问题。
掌握分支界限方法对于解决复杂问题具有重要的意义,也是算法设计和优化的关键技术之一。
分支界限方法在解决01背包问题的过程中,具有重要的作用。
01背包问题(动态规划法)

0/1背包问题1. 问题描述给定一个载重量为m,n个物品,其重量为w i,价值为v i,1<=i<=n,要求:把物品装入背包,并使包内物品价值最大2. 问题分析在0/1背包问题中,物体或者被装入背包,或者不被装入背包,只有两种选择。
循环变量i,j意义:前i个物品能够装入载重量为j的背包中(n+1)*(m+1)数组value意义:value[i][j]表示前i个物品能装入载重量为j的背包中物品的最大价值若w[i]>j,第i个物品不装入背包否则,若w[i]<=j且第i个物品装入背包后的价值>value[i-1][j],则记录当前最大价值(替换为第i个物品装入背包后的价值)计算最大价值的动态规划算法如下://计算for(i=1;i<row;i++){for(j=1;j<col;j++){//w[i]>j,第i个物品不装入背包value[i][j]=value[i-1][j];//w[i]<=j,且第i个物品装入背包后的价值>value[i-1][j],则记录当前最大价值int temp=value[i-1][j-w[i]]+v[i];if(w[i]<=j && temp>value[i][j])value[i][j]=temp;}}即该段程序完成以下n个阶段:1:只装入1个物品,确定在各种不同载重量的背包下,能够得到的最大价值2:装入2个物品,确定在各种不同载重量的背包下,能够得到的最大价值。
n:以此类推,装入n个物品,确定在各种不同载重量的背包下,能够得到的最大价值3. 问题求解确定装入背包的具体物品,从value[n][m]向前逆推:若value[n][m]>value[n-1][m],则第n个物品被装入背包,且前n-1个物品被装入载重量为m-w[n]的背包中否则,第n个物品没有装入背包,且前n-1个物品被装入载重量为m的背包中以此类推,直到确定第一个物品是否被装入背包为止。
蛮力法、动态规划法 求解01背包问题

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];//对应每种情况的最大价值
动态规划算法--01背包问题

动态规划算法--01背包问题基本思想:动态规划算法通常⽤于求解具有某种最优性质的问题。
在这类问题中,可能会有许多可⾏解。
每⼀个解都对应于⼀个值,我们希望找到具有最优值的解。
动态规划算法与分治法类似,其基本思想也是将待求解问题分解成若⼲个⼦问题,先求解⼦问题,然后从这些⼦问题的解得到原问题的解。
与分治法不同的是,适合于⽤动态规划求解的问题,经分解得到⼦问题往往不是互相独⽴的(即下⼀个⼦阶段的求解是建⽴在上⼀个⼦阶段的解的基础上,进⾏进⼀步的求解)。
若⽤分治法来解这类问题,则分解得到的⼦问题数⽬太多,有些⼦问题被重复计算了很多次。
如果我们能够保存已解决的⼦问题的答案,⽽在需要时再找出已求得的答案,这样就可以避免⼤量的重复计算,节省时间。
我们可以⽤⼀个表来记录所有已解的⼦问题的答案。
不管该⼦问题以后是否被⽤到,只要它被计算过,就将其结果填⼊表中。
这就是动态规划法的基本思路。
具体的动态规划算法多种多样,但它们具有相同的填表格式。
应⽤场景:适⽤动态规划的问题必须满⾜最优化原理、⽆后效性和重叠性。
1、最优化原理(最优⼦结构性质)最优化原理可这样阐述:⼀个最优化策略具有这样的性质,不论过去状态和决策如何,对前⾯的决策所形成的状态⽽⾔,余下的诸决策必须构成最优策略。
简⽽⾔之,⼀个最优化策略的⼦策略总是最优的。
⼀个问题满⾜最优化原理⼜称其具有最优⼦结构性质。
2、⽆后效性将各阶段按照⼀定的次序排列好之后,对于某个给定的阶段状态,它以前各阶段的状态⽆法直接影响它未来的决策,⽽只能通过当前的这个状态。
换句话说,每个状态都是过去历史的⼀个完整总结。
这就是⽆后向性,⼜称为⽆后效性。
3、⼦问题的重叠性动态规划将原来具有指数级时间复杂度的搜索算法改进成了具有多项式时间复杂度的算法。
其中的关键在于解决冗余,这是动态规划算法的根本⽬的。
动态规划实质上是⼀种以空间换时间的技术,它在实现的过程中,不得不存储产⽣过程中的各种状态,所以它的空间复杂度要⼤于其它的算法。
0-1背包问题的动态规划法与回溯法

0-1背包问题的动态规划法与回溯法⼀、动态规划状态转移⽅程:1从前往后:2if(j>=w[i])3 m[i][j]=max(m[i-1][j],m[i-1][j-w[i]]+v[i]);4else5 m[i][j]=m[i-1][j];67从后往前:8if(j>=w[i])9 m[i][j]=max(m[i+1][j],m[i+1][j-w[i]]+v[i]);10else11 m[i][j]=m[i+1][j];算法:1从前往后:2for(int i=1;i<=n;i++)3for(int j=1;j<=c;j++)4 {5if(j>=w[i])6 {7 m[i][j]=max(m[i-1][j],m[i-1][j-w[i]]+v[i]);8 }9else//这⾥没有考虑j<0的情况,因为算法中j取不到10 {11 m[i][j]=m[i-1][j];12 }13 }1415从后往前:16for(int i=n;i>=1;i--)17for(int j=1;j<=c;j++)18 {19if(j>=w[i])20 {21 m[i][j]=max(m[i+1][j],m[i+1][j-w[i]]+v[i]);22 }23else24 {25 m[i][j]=m[i+1][j];26 }27 }例⼦:例:0-1背包问题。
在使⽤动态规划算法求解0-1背包问题时,使⽤⼆维数组m[i][j]存储背包剩余容量为j,可选物品为i、i+1、……、n时0-1背包问题的最优值。
绘制重量数组w = {4, 6, 2, 2, 5, 1},价值数组v = {8, 10, 6, 3, 7, 2},背包容量C = 12时对应的m[i][j]数组。
(从前往后)例题代码 :1 #include<iostream>2 #include<cmath>3 #include<cstring>4#define N 205using namespace std;6int main()7 {8int w[N]={0,4,6,2,2,5,1},v[N]={0,8,10,6,3,7,2};9int m[N][N];10 memset(m,0,sizeof(m));11int n=6,c=12; //n,c均要⼩于N12for(int i=1;i<=n;i++)13for(int j=1;j<=c;j++)14 {15if(j>=w[i])16 {17 m[i][j]=max(m[i-1][j],m[i-1][j-w[i]]+v[i]);18 }19else20 {21 m[i][j]=m[i-1][j];22 }23 }24 cout<<m[n][c]<<endl; //从前往后2526/*27 for(int i=n;i>=1;i--)28 for(int j=1;j<=c;j++)29 {30 if(j>=w[i])31 {32 m[i][j]=max(m[i+1][j],m[i+1][j-w[i]]+v[i]);33 }34 else35 {36 m[i][j]=m[i+1][j];37 }38 }39 cout<<m[1][c]<<endl;//从后往前40*/41return0;42 }⼆、回溯法1进⼊左⼦树条件:cw+w[i]<=c //cw为当前重量2进⼊右⼦树条件(减枝函数):cp+r>bestp //cp为当前价值,bestp为当前最优价值,r为当前剩余物品价值总和。
动态规划算法-01背包问题

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));
NOI导刊资源背包动态规划

少。
剩下钱数最少的找零方案中的所需的最少 硬币数。
N<=500,T<=10000.
分析
设F[i]表示需要找的钱数为i时所需要的最少 钱币数。显然有:
F[i]=Min{F[ i - A[j] ] + 1} { i≤ T,1≤j≤N} 初始值:F[0]=0。 A[j]表示其中 第j种钱币的面值。 时间复杂度为O(N*T)。
动态规划
• 可以按每个物品进行规划,同样每种物品有选和 不选两种选择
• 设F(i,j)表示前i件物品载重为j的最大效益,则有
F(i 1, j w[i]) C[i],第i种物品装载 F(i, j) MaxF(i 1, j),第i种物品不装载
• 1<=i<=N, 0<=j<=N • 初值:F(0,j)=0 • F(N,M)即答案 • 显然时间复杂度为O(NM)
for j:=0 to m do
begin
if j>=w[i] then //背包容量够大
f[j]:=max(f[j-w[i]]+c[i],f[j])
end;
思考题1:机器分配
• M台设备,分给N个公司。 • 若公司i获得j台设备,则能产生Aij效益 • 问如何分配设备使得总效益最大? • M<=15,N<=10。
else
//背包容量不足
f[i,j]:=f[i-1,j];
end;
满背包问题(01背包)
• 有N件物品; • 第i件物品Wi公斤; • 第i件物品价值Ci元; • 现有一辆载重M公斤的卡车; • 问选取装载哪些物品,使得卡车开车正
好装满时,运送的总价值最大? 若无法装满卡车,则输出无解。
01背包问题动态规划算法

01背包问题动态规划算法
01背包问题是求在限定条件下,在一定的容量内最优装载物品,使得总价值最大。
动态规划算法是一种用于解决多阶段决策问题的途径,其特点是将原问题划分成若干子问题,每个子问题只求解一次,保存子问题的解,避免了重复计算。
01背包问题动态规划算法的步骤如下:
1、确定状态:物品的种数i (i=1,2,…n),背包的容量j (j=0,1,2,…V)。
2、确定状态转移方程:f[i][j]=max{f[i-1][j],f[i-1][j-wi]+vi}。
3、确定初始状态:f[i][0]=0,f[0][j]=0。
4、确定输出:最后f[n][V]即为最优解。
5、根据状态转移方程从左到右,从上到下进行迭代计算。
用动态规划法求解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背包问题,掌握动态规划算法求解问题的一般特征和步骤。
C语言动态规划之背包问题详解

C语⾔动态规划之背包问题详解01背包问题给定n种物品,和⼀个容量为C的背包,物品i的重量是w[i],其价值为v[i]。
问如何选择装⼊背包的物品,使得装⼊背包中的总价值最⼤?(⾯对每个武平,只能有选择拿取或者不拿两种选择,不能选择装⼊某物品的⼀部分,也不能装⼊物品多次)声明⼀个数组f[n][c]的⼆维数组,f[i][j]表⽰在⾯对第i件物品,且背包容量为j时所能获得的最⼤价值。
根据题⽬要求进⾏打表查找相关的边界和规律根据打表列写相关的状态转移⽅程⽤程序实现状态转移⽅程真题演练:⼀个旅⾏者有⼀个最多能装M公⽄的背包,现在有n件物品,它们的重量分别是W1、W2、W3、W4、…、Wn。
它们的价值分别是C1、C3、C2、…、Cn,求旅⾏者能获得最⼤价值。
输⼊描述:第⼀⾏:两个整数,M(背包容量,M<= 200)和N(物品数量,N<=30);第2…N+1⾏:每⾏两个整数Wi,Ci,表⽰每个物品的质量与价值。
输出描述:仅⼀⾏,⼀个数,表⽰最⼤总价值样例:输⼊:10 42 13 34 57 9输出:12解题步骤定义⼀个数组dp[i][j]表⽰容量为j时,拿第i个物品时所能获取的最⼤价值。
按照题⽬要求进⾏打表,列出对应的dp表。
W[i](质量)V[i](价值)01234567891000000000000210011111111133001334444444500135568899790013556991012对于⼀个动态规划问题设置下标时最好从0开始,因为动态规划经常会和上⼀个状态有关系!从上⾯的dp表可以看出来对于⼀个物品我们拿还是不难需要进⾏两步来判断。
第⼀步:判断背包当前的容量j是否⼤于物品当前的质量,如果物品的质量⼤于背包的容量那么就舍弃。
第⼆步:如果背包可以装下这个物品,就需要判断装下该物品获取的最⼤价值是不是⼤于不装下这个物品所获取的最⼤价值,如果⼤于那么就把东西装下!根据这样的思想我们可以得到状态转移⽅程:如果单签背包的容量可以装下物品:dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);如果当前背包的容量装不下该物品:dp[i][j]=dp[i-1][j];#include <stdio.h>int max(const int a,const int b){return a>b ? a:b;}int main(){int w[35]={0},v[35]={0},dp[35][210]={0};int n,m;scanf("%d %d",&m,&n);int i,j;for(i=1;i<=n;i++){scanf("%d %d",&w[i],&v[i]);}for(i=1;i<=n;i++){for(j=1;j<=m;j++){if(j>=w[i])//如果当前背包的容量⼤于商品的质量{dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);//判断是否应该拿下}else//⼤于背包的当前容量{dp[i][j]=dp[i-1][j];}}}for(int k=0;k<=n;k++){for(int l=0;l<=m;l++){printf("%d ",dp[k][l]);}printf("\n");}printf("%d\n",dp[n][m]);}通过运⾏以上程序可以看到最终的输出dp表和我们的预期是相符合的!但是并没有结束,动态规划有⼀个后⽆效性原则(当前状态只与前⼀个状态有关)。
动态规划01背包问题

01 背包问题的时间复杂度为 O(nW),空间复杂度为 O(nW)。
• 选择放入第 i 个物品。此时,背包的剩余容量为 j-w[i], 所以 f[i][j] = f[i-1][j-w[i]] + v[i]。 • 不选择放入第 i 个物品。此时,f[i][j] = f[i-1][j]。
综上所述,状态转移方程为:
f[i][j] = max(f[i-1][j], f[i-1][j-w[i]] + v[i])
01 背包问题是一种经典的动态规划问题,其目的是在限制条 件下,使得背包内的物品价值最大。
在 01 背包问题中,每种物品都有其体积和价值。同时,背 包也有一定的容量限制。问题的目标是在不超过背包容量的 前提下,使得背包内物品的价值最大。
为了解决 [j]表示前 i 个物品放入一个容量为 j 的背包可以获得的最大价值。然后,我们考虑第 i 个物品的 选择情况,其中有两种情况:
0-1背包问题动态规划详解及代码

0/1 背包问题动态规划详解及C代码动态规划是用空间换时间的一种方法的抽象。
其关键是发现子问题和记录其结果。
然后利用这些结果减轻运算量。
比如01背包问题。
/* 一个旅行者有一个最多能用M公斤的背包,现在有N件物品,它们的重量分别是W1,W2,...,Wn,它们的价值分别为P1,P2,...,Pn.若每种物品只有一件求旅行者能获得最大总价值。
输入格式:M,NW1,P1W2,P2......输出格式:X*/因为背包最大容量M未知。
所以,我们的程序要从1到M一个一个的试。
比如,开始任选N 件物品的一个。
看对应M的背包,能不能放进去,如果能放进去,并且还有多的空间,则,多出来的空间里能放N-1物品中的最大价值。
怎么能保证总选择是最大价值呢?看下表。
测试数据:10,33,44,55,6c[i][j]数组保存了1,2,3号物品依次选择后的最大价值.这个最大价值是怎么得来的呢?从背包容量为0开始,1号物品先试,0,1,2,的容量都不能放.所以置0,背包容量为3则里面放4.这样,这一排背包容量为4,5,6,....10的时候,最佳方案都是放4.假如1号物品放入背包.则再看2号物品.当背包容量为3的时候,最佳方案还是上一排的最价方案c为4.而背包容量为5的时候,则最佳方案为自己的重量5.背包容量为7的时候,很显然是5加上一个值了。
加谁??很显然是7-4=3的时候.上一排 c3的最佳方案是4.所以。
总的最佳方案是5+4为9.这样.一排一排推下去。
最右下放的数据就是最大的价值了。
(注意第3排的背包容量为7的时候,最佳方案不是本身的6.而是上一排的9.说明这时候3号物品没有被选.选的是1,2号物品.所以得9.)从以上最大价值的构造过程中可以看出。
f(n,m)=max{f(n-1,m), f(n-1,m-w[n])+P(n,m)}这就是书本上写的动态规划方程.这回清楚了吗?下面是实际程序(在VC 6.0环境下通过):#include<stdio.h>int c[10][100];/*对应每种情况的最大价值*/int knapsack(int m,int n){int i,j,w[10],p[10];printf("请输入每个物品的重量,价值:\n");for(i=1;i<=n;i++)scanf("%d,%d",&w[i],&p[i]);for(i=0;i<10;i++)for(j=0;j<100;j++)c[i][j]=0;/*初始化数组*/for(i=1;i<=n;i++)for(j=1;j<=m;j++){if(w[i]<=j) /*如果当前物品的容量小于背包容量*/{if(p[i]+c[i-1][j-w[i]]>c[i-1][j])/*如果本物品的价值加上背包剩下的空间能放的物品的价值*//*大于上一次选择的最佳方案则更新c[i][j]*/c[i][j]=p[i]+c[i-1][j-w[i]];elsec[i][j]=c[i-1][j];}else c[i][j]=c[i-1][j];}return(c[n][m]);}int main(){int m,n;int i,j;printf("请输入背包的承重量,物品的总个数:\n");scanf("%d,%d",&m,&n);printf("旅行者背包能装的最大总价值为%d",knapsack(m,n)); printf("\n");return 0;}。
动态规划之01背包问题

动态规划之01背包问题首先是问题描述:给定n种物品和一背包,物品i的重量是wi,其价值是pi,背包的容量是M,问如何选择装入背包中的物品总价值最大?可以这样理解:背包的背负有上限,因此在这个上限内尽可能多的装东西,并且价值越多越好。
在这里我之想讨论动态规划解决这个问题的详细过程。
动态规划是用空间换时间的一种方法的抽象。
其关键是发现子问题和记录其结果。
然后利用这些结果减轻运算量。
因为背包的最终最大容量未知,所以,我们得从1到M一个一个的试,比如,刚开始任选N件物品中的一个,看对应的M的背包,能不能放进去,如果能放进去,并且还有多少空间,则,多出来的空间能放N-1物品中的最大价值,怎么能保证总选则是最大价值呢,看下表:测试数据:10,33,44,55,6c[i][j]数组保存了1,2,3号物品依次选择后的最大价值.这个最大价值是怎么得来的呢?从背包容量为0开始,1号物品先试,0,1,2,的容量都不能放.所以置0,背包容量为3则里面放4.这样,这一排背包容量为4,5,6,....10的时候,最佳方案都是放4.假如1号物品放入背包.则再看2号物品.当背包容量为3的时候,最佳方案还是上一排的最价方案c为4.而背包容量为5的时候,则最佳方案为自己的重量5.背包容量为7的时候,很显然是5加上一个值了。
加谁??很显然是7-4=3的时候.上一排c3的最佳方案是4.所以。
总的最佳方案是5+4为9.这样.一排一排推下去。
最右下放的数据就是最大的价值了。
(注意第3排的背包容量为7的时候,最佳方案不是本身的6.而是上一排的9.说明这时候3号物品没有被选.选的是1,2号物品.所以得9.从以上最大价值的构造过程中可以看出。
f(n,m)=max{f(n-1,m), f(n-1,m-w[n])+P(n,m)}这就是书本上写的动态规划方程.下面是一种实现过程:(C语言描述)#include<stdio.h>int c[10][100];int knapsack(int m,int n){int i,j,w[10],p[10];for(i=1;i<n+1;i++)scanf("\n%d,%d",&w[i],&p[i]);for(i=0;i<10;i++)for(j=0;j<100;j++)c[i][j]=0;for(i=1;i<n+1;i++)for(j=1;j<m+1;j++){if(w[i]<=j){if(p[i]+c[i-1][j-w[i]]>c[i-1][j])c[i][j]=p[i]+c[i-1][j-w[i]];elsec[i][j]=c[i-1][j];}elsec[i][j]=c[i-1][j];}return(c[n][m]);}int main(){int m,n;int i,j;printf("input the max capacity and the number of the goods:\n"); scanf("%d,%d",&m,&n);printf("Input each one(weight and value):\n");printf("%d",knapsack(m,n));printf("\n");for(i=0;i<10;i++)for(j=0;j<15;j++){printf("%d ",c[i][j]);if(j==14)printf("\n");}system("pause");}下面是思路的基本过程问题的特点是:每种物品一件,可以选择放1或不放0。
动态规划算法0-1背包问题课件PPT

回溯法
要点一
总结词
通过递归和剪枝来减少搜索空间,但仍然时间复杂度高。
要点二
详细描述
回溯法是一种基于递归的搜索算法,通过深度优先搜索来 找出所有可能的解。在0-1背包问题中,回溯法会尝试将物 品放入背包中,并递归地考虑下一个物品。如果当前物品 无法放入背包或放入背包的总价值不增加,则剪枝该分支 。回溯法能够避免搜索一些无效的组合,但仍然需要遍历 所有可能的组合,时间复杂度较高。
缺点
需要存储所有子问题的解,因此空间 复杂度较高。对于状态转移方程的确 定和状态空间的填充需要仔细考虑, 否则可能导致错误的结果。
04
0-1背包问题的动态规划解法
状态定义
状态定义
dp[i][ j]表示在前i个物品中选,总 重量不超过j的情况下,能够获得 的最大价值。
状态转移方程
dp[i][ j] = max(dp[i-1][ j], dp[i1][ j-w[i]] + v[i]),其中w[i]和v[i] 分别表示第i个物品的重量和价值。
02
计算时间复杂度:时间复杂度是指求解问题所需的时间与问题规模之间的关系。对 于0-1背包问题,时间复杂度主要取决于状态总数。由于每个状态都需要被遍历, 因此时间复杂度为O(2^n),其中n是物品的数量。
03
空间复杂度:空间复杂度是指求解问题所需的空间与问题规模之间的关系。在0-1 背包问题中,空间复杂度主要取决于状态总数。由于每个状态都需要被存储,因此 空间复杂度也为O(2^n),其中n是物品的数量。
06
0-1背包问题的扩展和实际应用
多多个物品和多个 背包,每个物品有各自的重量和价值, 每个背包有各自的容量,目标是选择物 品,使得在不超过背包容量限制的情况 下,所选物品的总价值最大。
蛮力法、动态规划法、回溯法和分支限界法求解01背包问题

一、实验内容:分别用蛮力法、动态规划法、回溯法和分支限界法求解0/1背包问题。
注:0/1背包问题:给定n 种物品和一个容量为C 的背包,物品i 的重量是i w ,其价值为i v ,背包问题是如何使选择装入背包内的物品,使得装入背包中的物品的总价值最大。
其中,每种物品只有全部装入背包或不装入背包两种选择。
二、所用算法的基本思想及复杂度分析:1.蛮力法求解0/1背包问题:1)基本思想:对于有n 种可选物品的0/1背包问题,其解空间由长度为n 的0-1向量组成,可用子集数表示。
在搜索解空间树时,深度优先遍历,搜索每一个结点,无论是否可能产生最优解,都遍历至叶子结点,记录每次得到的装入总价值,然后记录遍历过的最大价值。
2)代码:#include<iostream>#include<algorithm>using namespace std;#define N 100 //最多可能物体数struct goods //物品结构体{int sign; //物品序号int w; //物品重量int p; //物品价值}a[N];bool m(goods a,goods b){return (a.p/a.w)>(b.p/b.w);}int max(int a,int b){return a<b?b:a;}int n,C,bestP=0,cp=0,cw=0;int X[N],cx[N];/*蛮力法求解0/1背包问题*/int Force(int i){if(i>n-1){if(bestP<cp&&cw+a[i].w<=C){for (int k=0;k<n;k++) X[k]=cx[k];//存储最优路径 bestP=cp;}return bestP;}cw=cw+a[i].w;cp=cp+a[i].p;cx[i]=1; //装入背包Force(i+1);cw=cw-a[i].w;cp=cp-a[i].p;cx[i]=0; //不装入背包Force(i+1);return bestP;}int KnapSack1(int n,goods a[],int C,int x[]){Force(0);return bestP;}int main(){goods b[N];printf("物品种数n: ");scanf("%d",&n); //输入物品种数printf("背包容量C: ");scanf("%d",&C); //输入背包容量for (int i=0;i<n;i++) //输入物品i 的重量w 及其价值v {printf("物品%d 的重量w[%d]及其价值v[%d]: ",i+1,i+1,i+1);scanf("%d%d",&a[i].w,&a[i].p);b[i]=a[i];}int sum1=KnapSack1(n,a,C,X);//调用蛮力法求0/1背包问题 printf("蛮力法求解0/1背包问题:\nX=[ ");for(i=0;i<n;i++)cout<<X[i]<<" ";//输出所求X[n]矩阵printf("] 装入总价值%d\n",sum1);bestP=0,cp=0,cw=0;//恢复初始化}3)复杂度分析:蛮力法求解0/1背包问题的时间复杂度为:)2()(n O n T 。
动态规划之01背包问题

动态规划之01背包问题01背包问题问题描述:给定 n 件物品,物品的重量为 w[i],物品的价值为 c[i]。
现挑选物品放⼊背包中,假定背包能承受的最⼤重量为 V,问应该如何选择装⼊背包中的物品,使得装⼊背包中物品的总价值最⼤?针对这个问题,本⼈理解了多次,也了看各种题解,尝试各种办法总还觉得抽象;或者说,看了多次以后,只是把题解的状态转移⽅程记住了⽽已,并没有真正的“掌握”其背后的逻辑。
直到我看了,在此感谢作者并记录于此。
01背包问题之另⼀种风格的描述:假设你是⼀个⼩偷,背着⼀个可装下4磅东西的背包,你可以偷窃的物品如下:为了让偷窃的商品价值最⾼,你该选择哪些商品?暴⼒解法最简单的算法是:尝试各种可能的商品组合,并找出价值最⾼的组合。
这样显然是可⾏的,但是速度⾮常慢。
在只有3件商品的情况下,你需要计算8个不同的集合;当有4件商品的时候,你需要计算16个不同的集合。
每增加⼀件商品,需要计算的集合数都将翻倍!对于每⼀件商品,都有选或不选两种可能,即这种算法的运⾏时间是O(2ⁿ)。
动态规划解决这样问题的答案就是使⽤动态规划!下⾯来看看动态规划的⼯作原理。
动态规划先解决⼦问题,再逐步解决⼤问题。
对于背包问题,你先解决⼩背包(⼦背包)问题,再逐步解决原来的问题。
⽐较有趣的⼀句话是:每个动态规划都从⼀个⽹格开始。
(所以学会⽹格的推导⾄关重要,⽽有些题解之所以写的不好,就是因为没有给出⽹格的推导过程,或者说,没有说清楚为什么要”这样“设计⽹格。
本⽂恰是解决了我这⽅⾯长久以来的困惑!)背包问题的⽹格如下:⽹格的各⾏表⽰商品,各列代表不同容量(1~4磅)的背包。
所有这些列你都需要,因为它们将帮助你计算⼦背包的价值。
⽹格最初是空的。
你将填充其中的每个单元格,⽹格填满后,就找到了问题的答案!1. 吉他⾏后⾯会列出计算这个⽹格中单元格值得公式,但现在我们先来⼀步⼀步做。
⾸先来看第⼀⾏。
这是吉他⾏,意味着你将尝试将吉他装⼊背包。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
0/1背包问题1. 问题描述给定一个载重量为m,n个物品,其重量为w i,价值为v i,1<=i<=n,要求:把物品装入背包,并使包内物品价值最大2. 问题分析在0/1背包问题中,物体或者被装入背包,或者不被装入背包,只有两种选择。
循环变量i,j意义:前i个物品能够装入载重量为j的背包中(n+1)*(m+1)数组value意义:value[i][j]表示前i个物品能装入载重量为j的背包中物品的最大价值若w[i]>j,第i个物品不装入背包否则,若w[i]<=j且第i个物品装入背包后的价值>value[i-1][j],则记录当前最大价值(替换为第i个物品装入背包后的价值)计算最大价值的动态规划算法如下://计算for(i=1;i<row;i++){for(j=1;j<col;j++){//w[i]>j,第i个物品不装入背包value[i][j]=value[i-1][j];//w[i]<=j,且第i个物品装入背包后的价值>value[i-1][j],则记录当前最大价值int temp=value[i-1][j-w[i]]+v[i];if(w[i]<=j && temp>value[i][j])value[i][j]=temp;}}即该段程序完成以下n个阶段:1:只装入1个物品,确定在各种不同载重量的背包下,能够得到的最大价值2:装入2个物品,确定在各种不同载重量的背包下,能够得到的最大价值。
n:以此类推,装入n个物品,确定在各种不同载重量的背包下,能够得到的最大价值3. 问题求解确定装入背包的具体物品,从value[n][m]向前逆推:若value[n][m]>value[n-1][m],则第n个物品被装入背包,且前n-1个物品被装入载重量为m-w[n]的背包中否则,第n个物品没有装入背包,且前n-1个物品被装入载重量为m的背包中以此类推,直到确定第一个物品是否被装入背包为止。
逆推代码如下://逆推求装入的物品j=m;for(i=row-1;i>0;i--){if(value[i][j]>value[i-1][j]){c[i]=1;j-=w[i];}}4. 代码如下输入数据及输出数据均在文件中。
输入数据格式:n mw1 w2 ... w nv1 v2 ... vn输出数据格式:maxValuei count //i表示物品编号,count表示该物品被选中次数 .../************************************************************************* 0/1背包问题求解 (visual studio 2005)* 给定一个载重量为m,及n个物品,其重量为wi,价值为vi,1<=i<=n* 要求:把物品装入背包,并使包内物品价值最大************************************************************************/#include <stdio.h>#include <stdlib.h>#include <string.h>#define FILENAMELENGTH 100class CBeibao{public:int m_nNumber; //物品数量int m_nMaxWeight; //最大载重量int *m_pWeight; //每个物品的重量int *m_pValue; //每个物品的价值int *m_pCount; //每个物品被选中的次数int m_nMaxValue; //最大价值public:CBeibao(const char *filename);~CBeibao();int GetMaxValue();int GetMaxValue(int n,int m,int *w,int *v,int *c);void Display(int nMaxValue);void Display(int nMaxValue,const char *filename); };//读入数据CBeibao::CBeibao(const char *filename){FILE *fp=fopen(filename,"r");if(fp==NULL){printf("can not open file!");return; //exit(0);}//读入物品数量和最大载重量fscanf(fp,"%d%d",&m_nNumber,&m_nMaxWeight);m_pWeight=new int[m_nNumber+1];m_pValue=new int[m_nNumber+1];m_pWeight[0]=0;//读入每个物品的重量for(int i=1;i<=m_nNumber;i++)fscanf(fp,"%d",m_pWeight+i);m_pValue[0]=0;//读入每个物品的价值for(int i=1;i<=m_nNumber;i++)fscanf(fp,"%d",m_pValue+i);//初始化每个物品被选中次数为0m_pCount=new int[m_nNumber+1];for(int i=0;i<=m_nNumber;i++)m_pCount[i]=0;fclose(fp);}CBeibao::~CBeibao(){delete[] m_pWeight;m_pWeight=NULL;delete[] m_pValue;m_pValue=NULL;delete[] m_pCount;m_pCount=NULL;}/************************************************************************* 动态规划求出满足最大载重量的最大价值* 参数说明:n:物品个数* m:背包载重量* w:重量数组* v:价值数组* c:是否被选中数组* 返回值:最大价值************************************************************************/int CBeibao::GetMaxValue(int n,int m,int *w,int *v,int *c){int row=n+1;int col=m+1;int i,j; //循环变量:前i个物品能够装入载重量为j的背包中//value[i][j]表示前i个物品能装入载重量为j的背包中物品的最大价值int **value=new int*[row];for(i=0;i<row;i++)value[i]=new int[col];//初始化第0行for(j=0;j<col;j++)value[0][j]=0;//初始化第0列for(i=0;i<row;i++)value[i][0]=0;//计算for(i=1;i<row;i++){for(j=1;j<col;j++){//w[i]>j,第i个物品不装入背包value[i][j]=value[i-1][j];//w[i]<=j,且第i个物品装入背包后的价值>value[i-1][j],则记录当前最大价值int temp=value[i-1][j-w[i]]+v[i];if(w[i]<=j && temp>value[i][j])value[i][j]=temp;}}//逆推求装入的物品j=m;for(i=row-1;i>0;i--){if(value[i][j]>value[i-1][j]){c[i]=1;j-=w[i];}}//记录最大价值int nMaxVlaue=value[row-1][col-1];//释放该二维数组for(i=0;i<row;i++){delete [col]value[i];value[i]=NULL;}delete[] value;value=NULL;return nMaxVlaue;}int CBeibao::GetMaxValue(){int nValue=GetMaxValue(m_nNumber,m_nMaxWeight,m_pWeight,m_pValue,m_pC ount);m_nMaxValue=nValue;return nValue;}//显示结果void CBeibao::Display(int nMaxValue){printf(" %d ",nMaxValue);for(int i=1;i<=m_nNumber;i++){if(m_pCount[i])printf(" %d %d ",i,m_pCount[i]);}printf(" ");}void CBeibao::Display(int nMaxValue,const char *filename){FILE *fp=fopen(filename,"w");if(fp==NULL){printf("can not write file!");return; //exit(0);}fprintf(fp,"%d ",nMaxValue);for(int i=1;i<=m_nNumber;i++){if(m_pCount[i])fprintf(fp,"%d %d ",i,m_pCount[i]);}fclose(fp);}//显示菜单void show_menu(){printf("--------------------------------------------- ");printf("input command to test the program ");printf(" i or I : input filename to test ");printf(" q or Q : quit ");printf("--------------------------------------------- ");printf("$ input command >");}void main(){char sinput[10];char sfilename[FILENAMELENGTH];show_menu();scanf("%s",sinput);while(stricmp(sinput,"q")!=0){if(stricmp(sinput,"i")==0){printf(" please input a filename:");scanf("%s",sfilename);//获取满足最大载重量的最大价值CBeibao beibao(sfilename);int nMaxValue=beibao.GetMaxValue();if(nMaxValue){beibao.Display(nMaxValue);int nlen=strlen(sfilename);strcpy(sfilename+nlen-4,"_result.txt");beibao.Display(nMaxValue,sfilename);}elseprintf(" error! please check the input data! ");}//输入命令printf("$ input command >");scanf("%s",sinput);}}5. 运行结果如下文件中的内容如下:1. input.txt4 102 3 4 71 3 5 9input_result.txt122 14 12. input1.txt5 102 2 6 5 46 3 5 4 6input1_result.txt151 12 15 13. input2.txt5 152 6 4 7 91 6 5 9 4input2_result.txt161 12 14 14. input3.txt10 10512 16 24 7 29 32 5 43 31 111 16 15 9 24 25 3 32 41 7input3_result.txt1121 12 14 16 17 19 110 1。