贪心算法0-1背包问题(算法实验代码)

合集下载

0-1背包问题的分支限界法源代码

0-1背包问题的分支限界法源代码
{
int i;
n=nn;
c=cc;
p=new int[n];
w=new int[n];
M=new int[n];
for(i=0;i<n;i++)
{
p[i]=pp[i];
w[i]=ww[i];
M[i]=i; //用M数组记录大小顺序关系
}
front=new node[1];
front->next=NULL;
cin>>w[i];
cout<<endl;
cout<<"请输入这"<<n<<"个物品的价值P:"<<endl;
for(i=0;i<n;i++)
cin>>p[i];
Knap knbag(p,w,c,n);
knbag.solvebag();
getch();
return 0;
}
//#include "stdafx.h"
#include<iostream>
#include<cstdio>
#include<conio.h>
#include<iomanip>
using namespace std;
int *x;
struct node //结点表结点数据结构
{
node *parent;//父结点指针
{
minl=1.0*p[i]/w[i];
k=0;
for(j=1;j<=n-i;j++)
{
if(minl<1.0*p[j]/w[j])

分支限界法求0-1背包问题实验程序以及代码(C++)

分支限界法求0-1背包问题实验程序以及代码(C++)

分支限界法求0-1背包问题实验程序以及代码(C++)本程序中(规定物品数量为3,背包容量为30,输入为6个数,前3个为物品重量,后3个数为物品价值):代码:#include<iostream>#include<stack>using namespace std;#define N 100classHeapNode //定义HeapNode结点类{public:doubleupper,price,weight; //upper为结点的价值上界,price是结点所对应的价值,weight为结点所相应的重量int level,x[N]; //活节点在子集树中所处的层序号};double MaxBound(int i);double Knap();void AddLiveNode(double up,double cp,double cw,bool ch,int level);stack<HeapNode>High; //最大队Highdouble w[N],p[N]; //把物品重量和价值定义为双精度浮点数double cw,cp,c=30; //cw为当前重量,cp为当前价值,定义背包容量为30int n=3; //货物数量为3int main(){cout<<"请按顺序输入3个物品的重量:(按回车键区分每个物品的重量)"<<endl;int i;for(i=1;i<=n;i++)cin>>w[i]; //输入3个物品的重量cout<<"请按顺序输入3个物品的价值:(按回车键区分每个物品的价值)"<<endl;for(i=1;i<=n;i++)cin>>p[i]; //输入3个物品的价值cout<<"最大价值为:";cout<<Knap()<<endl; //调用knap函数输出最大价值return 0;}double MaxBound(int j) //MaxBound函数求最大上界{doubleleft=c-cw,b=cp; //剩余容量和价值上界while(j<=n&&w[j]<=left) //以物品单位重量价值递减装填剩余容量{left-=w[j];b+=p[j];j++;}if(j<=n)b+=p[j]/w[j]*left; //装填剩余容量装满背包return b;}void AddLiveNode(double up,double cp,double cw,bool ch,int lev)//将一个新的活结点插入到子集数和最大堆High中{HeapNode be;be.upper=up;be.price=cp;be.weight=cw;be.level=lev;if(lev<=n)High.push(be); //调用stack头文件的push函数}double Knap() //优先队列分支限界法,返回最大价值,bestx返回最优解{ int i=1; cw=cp=0; doublebestp=0,up=MaxBound(1); //调用MaxBound求出价值上界,best为最优值while(1) //非叶子结点{ double wt=cw+w[i];if(wt<=c) //左儿子结点为可行结点{ if(cp+p[i]>bestp) bestp=cp+p[i];AddLiveNode(up,cp+p[i],cw+w[i],true,i+1);}up=MaxBound(i+1);if(up>=bestp) //右子数可能含最优解AddLiveNode(up,cp,cw,false,i+1);if(High.empty()) return bestp;HeapNode node=High.top(); //取下一扩展结点High.pop(); cw=node.weight; cp=node.price; up=node.upper; i=node.level;}}输出结果为:。

01背包问题c语言代码回溯法

01背包问题c语言代码回溯法

以下是使用C语言实现01背包问题的回溯法代码:```c#include <stdio.h>#include <stdlib.h>// 初始化背包struct knapsack {int maxWeight; // 背包最大承重int *items; // 物品数组int n; // 物品数量};// 定义物品重量、价值和数量int weights[] = {2, 2, 6, 5, 4};int values[] = {6, 3, 5, 4, 6};int quantities[] = {3, 2, 2, 1, 1};// 初始化背包最大承重和当前承重int maxWeight = 10;int currentWeight = 0;// 初始化最大价值为0int maxValue = 0;// 遍历物品数组void traverseItems(struct knapsack *knapsack, int index) { // 对于每个物品,遍历其数量for (int i = 0; i < knapsack->quantities[index]; i++) {// 如果当前物品可以放入背包装且当前承重不超过背包最大承重,计算放入该物品后的总价值,并更新最大价值if (currentWeight + weights[index] <= knapsack->maxWeight) {int currentValue = values[index] * knapsack->quantities[index];if (currentValue > maxValue) {maxValue = currentValue;}}// 回溯,将当前物品从背包装中移除,递归地尝试下一个物品knapsack->quantities[index]--;if (index < knapsack->n - 1) {traverseItems(knapsack, index + 1);}knapsack->quantities[index]++; // 恢复物品数量,以便下次遍历尝试放入其他物品}}// 主函数int main() {// 初始化背包装和物品数组struct knapsack knapsack = {maxWeight, weights, 5};knapsack.items = (int *)malloc(sizeof(int) * knapsack.n);for (int i = 0; i < knapsack.n; i++) {knapsack.items[i] = values[i] * quantities[i]; // 根据价值和数量计算物品价值,并存储在物品数组中}knapsack.n = quantities[4]; // 由于最后一个物品的数量为1,因此只需遍历前n-1个物品即可得到所有可能的结果// 使用回溯法求解01背包问题,返回最大价值traverseItems(&knapsack, 0);printf("The maximum value is %d.\n", maxValue);free(knapsack.items); // 释放内存空间return 0;}```希望以上信息能帮助到你。

贪心算法背包问题

贪心算法背包问题
算法设计与分析实验报告
题目:贪心算法
背包问题
专业:JAVA 技术 09——02 班 学号:540913100201 姓名:柏顺顺 指导老师:宋胜利
实验三:贪心算法
一、实验目的与要求
1、掌握背包问题的算法 2、初步掌握贪心算法
背包问题
二、实验题:
问题描述:与 0-1 背包问题相似,给定 n 种物品和一个背包。物品 i 的重量是 wi,其价 值为 vi,背包的容量为 c。与 0-1 背包问题不同的是,在选择物品 i 装入背包时,背包问题 的解决可以选择物品 i 的一部分,而不一定要全部装入背包,1< i < n。
JOptionPane.showMessageDialog(null, "重量不能为空!"); return; } else{ if (s1.equals("")){ JOptionPane.showMessageDialog(null, "效益值不能为空!"); return; }else { if (s3.equals("")) JOptionPane.showMessageDialog(null, "总重量不能为空!"); return; } } } catch (Exception e3) { // TODO: handle exception }
}
//可以执行贪心算法了 int [] wCopy = new int [w.length]; int [] pCopy = new int [w.length]; float temp2; int temp1; float totalx=0; float [] x = new float [w.length];//效益和重量的比值 float [] n =new float[w.length];//记录个数 float [] nCopy = new float[w.length]; for(int i=0;i<w.length;i++) { wCopy [i] = w[i]; pCopy [i] = p[i]; } for (int i=0;i<w.length;i++) x[i] = (float) ((p[i]*1.0)/w[i]); for(int i= 0;i<w.length;i++) for(int j=i+1;j<w.length;j++)

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。

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

贪心算法之背包问题

贪心算法之背包问题

贪⼼算法之背包问题贪⼼算法之背包问题1.与动态规划的区别通过研究解决经典的组合优化问题,来说明⼆者的差别。

即0-1背包问题与背包问题0-1背包问题:给定n中物品和⼀个背包。

物品i的重量为W i,其价值为V i,背包的容量为C。

应如何选择装⼊背包的物品,使得装⼊背包中物品的总价值最⼤?对于每种物品i只有俩种选择,即装⼊背包或不装⼊背包背包问题:与0-1背包问题类似,不同在于选择物品i装⼊背包时,可以选择物品i的⼀部分,⽽不⼀定要全部装⼊背包,1≤i≤n。

这2类问题都具有最优⼦结构性质,极为相似。

背包问题可以⽤贪⼼算法求最优解,0-1背包不能使⽤贪⼼求解。

2.贪⼼解决背包问题步骤贪⼼策略:每次选择单位重量价值最⾼的物品装⼊背包计算每种物品单位重量的价值V iW i,按单位重量的价值从⼤到⼩将n中物品排序。

以排序后的次序依次将物品装⼊背包。

直⾄全部物品都装⼊或者因背包容量不⾜不能装⼊为⽌如果背包尚有容量,将最后不能完全装⼊物品切割⼀部分装满背包算法结束3.代码实现/*** n 物品数* M 背包容量* v[] 物品价值数组* w[] 物品重量数组* x[] 保存最优解路径数组,为1则表⽰该物品完全装⼊,否则装⼊该物品的⼀部分**/void Knapsack(int n, float M, float v[], float w[], float x[]) {// 按照物品单位重量的价值递减排序Sort(n, v, w);int i;for (i = 1; i <= n; i++)x[i] = 0;float c = M;for (i = 1; i <= n; i++) {if (w[i] > c)break;x[i] = 1;c -= w[i];}if (i <= n)x[i] = c / w[i];}Processing math: 100%。

0-1背包问题-贪心法和动态规划法求解

0-1背包问题-贪心法和动态规划法求解

实验四“0-1”背包问题一、实验目的与要求熟悉C/C++语言的集成开发环境;通过本实验加深对贪心算法、动态规划算法的理解。

二、实验内容:掌握贪心算法、动态规划算法的概念和基本思想,分析并掌握“0-1”背包问题的求解方法,并分析其优缺点。

三、实验题1.“0-1”背包问题的贪心算法2.“0-1”背包问题的动态规划算法说明:背包实例采用教材P132习题六的6-1中的描述。

要求每种的算法都给出最大收益和最优解。

设有背包问题实例n=7,M=15,,(w0,w1,。

w6)=(2,3,5,7,1,4,1),物品装入背包的收益为:(p0,p1,。

,p6)=(10,5,15,7,6,18,3)。

求这一实例的最优解和最大收益。

四、实验步骤理解算法思想和问题要求;编程实现题目要求;上机输入和调试自己所编的程序;验证分析实验结果;整理出实验报告。

五、实验程序// 贪心法求解#include<iostream>#include"iomanip"using namespace std;//按照单位物品收益排序,传入参数单位物品收益,物品收益和物品重量的数组,运用冒泡排序void AvgBenefitsSort(float *arry_avgp,float *arry_p,float *arry_w ); //获取最优解方法,传入参数为物品收益数组,物品重量数组,最后装载物品最优解的数组和还可以装载物品的重量float GetBestBenifit(float*arry_p,float*arry_w,float*arry_x,float u);int main(){float w[7]={2,3,5,7,1,4,1}; //物品重量数组float p[7]={10,5,15,7,6,18,3}; //物品收益数组float avgp[7]={0}; //单位毒品的收益数组float x[7]={0}; //最后装载物品的最优解数组const float M=15; //背包所能的载重float ben=0; //最后的收益AvgBenefitsSort(avgp,p,w);ben=GetBestBenifit(p,w,x,M);cout<<endl<<ben<<endl; //输出最后的收益system("pause");return 0;}//按照单位物品收益排序,传入参数单位物品收益,物品收益和物品重量的数组,运用冒泡排序void AvgBenefitsSort(float *arry_avgp,float *arry_p,float *arry_w ) {//求出物品的单位收益for(int i=0;i<7;i++){arry_avgp[i]=arry_p[i]/arry_w[i];}cout<<endl;//把求出的单位收益排序,冒泡排序法int exchange=7;int bound=0;float temp=0;while(exchange){bound=exchange;exchange=0;for(int i=0;i<bound;i++){if(arry_avgp[i]<arry_avgp[i+1]){//交换单位收益数组temp=arry_avgp[i];arry_avgp[i]=arry_avgp[i+1];arry_avgp[i+1]=temp;//交换收益数组temp=arry_p[i];arry_p[i]=arry_p[i+1];arry_p[i+1]=temp;//交换重量数组temp=arry_w[i];arry_w[i]=arry_w[i+1];arry_w[i+1]=temp;exchange=i;}}}}//获取最优解方法,传入参数为物品收益数组,物品重量数组,最后装载物品最优解的数组和还可以装载物品的重量float GetBestBenifit(float*arry_p,float*arry_w,float*arry_x,float u) {int i=0; //循环变量ifloat benifit=0; //最后收益while(i<7){if(u-arry_w[i]>0){arry_x[i]=arry_w[i]; //把当前物品重量缴入最优解数组benifit+=arry_p[i]; //收益增加当前物品收益u-=arry_w[i]; //背包还能载重量减去当前物品重量cout<<arry_x[i]<<" "; //输出最优解}i++;}return benifit; //返回最后收益}//动态规划法求解#include<stdio.h>#include<math.h>#define n 6void DKNAP(int p[],int w[],int M,const int m); void main(){int p[n+1],w[n+1];int M,i,j;int m=1;for(i=1;i<=n;i++){m=m*2;printf("\nin put the weight and the p:");scanf("%d %d",&w[i],&p[i]);}printf("%d",m);printf("\n in put the max weight M:");scanf("%d",&M);DKNAP(p,w,M,m);}void DKNAP(int p[],int w[],int M,const int m) {int p2[m],w2[m],pp,ww,px;int F[n+1],pk,q,k,l,h,u,i,j,next,max,s[n+1];F[0]=1;p2[1]=w2[1]=0;l=h=1;F[1]=next=2;for(i=1;i<n;i++){k=l;max=0;u=l;for(q=l;q<=h;q++)if((w2[q]+w[i]<=M)&&max<=w2[q]+w[i]){u=q;max=w2[q]+w[i];}for(j=l;j<=u;j++){pp=p2[j]+p[i];ww=w2[j]+w[i];while(k<=h&&w2[k]<ww){p2[next]=p2[k];w2[next]=w2[k];next++;k++;}if(k<=h&&w2[k]==ww){if(pp<=p2[k])pp=p2[k];k++;}else if(pp>p2[next-1]){p2[next]=pp;w2[next]=ww;next++;}while(k<=h&&p2[k]<=p2[next-1])k++;}while(k<=h){p2[next]=p2[k];w2[next]=w2[k];next=next+1;k++;}l=h+1;h=next-1;F[i+1]=next;}for(i=1;i<next;i++)printf("%2d%2d ",p2[i],w2[i]);for(i=n;i>0;i--){next=F[i];next--;pp=pk=p2[next];ww=w2[next];while(ww+w[i]>M&&next>F[i-1]){next=next-1;pp=p2[next];ww=w2[next];}if(ww+w[i]<=M&&next>F[i-1])px=pp+p[i];if(px>pk&&ww+w[i]<=M){s[i]=1;M=M-w[i];printf("M=%d ",M);}else s[i]=0;}for(i=1;i<=n;i++)printf("%2d ",s[i]);}六、实验结果1、贪心法截图:七、实验分析。

0-1背包问题动态规划和贪心法实现

0-1背包问题动态规划和贪心法实现

算法设计与分析实验报告实验二 0-1背包问题院系:班级:计算机科学与技术学号:姓名:任课教师:成绩:湘潭大学2016年5月实验二0-1背包问题一. 实验内容分别编程实现动态规划算法和贪心法求0-1背包问题的最优解,分析比较两种算法的时间复杂度并验证分析结果。

二.实验目的1、掌握动态规划算法和贪心法解决问题的一般步骤,学会使用动态规划和贪心法解决实际问题;2、理解动态规划算法和贪心法的异同及各自的适用范围。

三. 算法描述/*动态规划 0-1背包问题算法如下*/Template<class Type>Void Knapsack(Type v,int w,int c,int n,Type ** m){int jMax = min(w[n] - 1,c);For(int j = 0;j <= jMax;j++){m[n][j] = 0;}For(int j = w[n];j <= c;j++){m[n][j] = v[n];}For(int i = n- 1;i > 1;i--){jMax = min(w[i] - 1,c);For(int j = 0;j <= jMax;j++) m[i][j] = m[i+1][j];For(int j = w[i];j <= c;j++) min[i][j] = max(m[i+1][j],m[i+1][j-w[i]]+v[i]);}m[1][c] = m[2][c];If(c >= w[1]) m[1][c] = max(m[1][c],m[2][c-w[1]]+v[1]);}Template<class Type>Void Traceback(Type**m,int w,int c,int n,int x){for(int i =1 ;i < n;i ++)If(m[i][c] == m[i+1][c]) x[i] = 0;Else{x[i] = 1;c -=w[i];}x[n] = (m[n][c]) ? 1:0;}按上述算法Knapsack计算后m[1][c]给出所要求的0-1背包问题的最优解。

0-1背包问题动态规划详解及代码

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;}。

遗传算法求解0-1背包问题(步骤)(精)

遗传算法求解0-1背包问题(步骤)(精)

遗传算法求解0-1背包问题。

(步骤)#include "iostream.h"#include "iomanip.h"#include "stdlib.h"#include "math.h"#include "time.h"//定义问题的最大规模#define max 100//问题规模,即共有多少个包int packageNum;//每个包的重量int packageWeight[max];//每个包的价值int packageValue[max];//约束,背包的最大容量int limitWeight;//群体的规模int colonySize;//colonyState[i][k] 表示一个染色体//colonyState[1...colonySize][ 0|1 ] 表示一代群体int colonyState[max][2][max];// currAge 表示当前代的编号// (currAge+1)%2 表示下一代的编号int currAge = 0;//个体评价信息表typedef struct tagIndividualMsg{int index;int value;} IndividualMsg;IndividualMsg individualMsg[max];//////////////////////////////////////////////////////////// // 函数声明void printColonyState( int nextAge );//////////////////////////////////////////////////////////// //初始化群体void colonyInit(){int i , j;int w;for( i = 0 ; i < colonySize ; i++ ){//保证找到一个符合约束的染色体w = limitWeight + 1;while( w > limitWeight ){w = 0;for( j = 0 ; j < packageNum && w <= limitWeight ; j++ ){colonyState[i][currAge][j] = rand() % 2;w += packageWeight[j] * colonyState[i][currAge][j];}}}}//对个体进行评价int cmp( const void *a , const void *b ){IndividualMsg *x = (IndividualMsg *)a;IndividualMsg *y = (IndividualMsg *)b;return y->value - x->value;}void individualEstimate(){int i , j;for( i = 0 ; i < colonySize ; i++ ){individualMsg[i].index = i;individualMsg[i].value = 0;for( j = 0 ; j < packageNum ; j++ )individualMsg[i].value += packageValue[j] * colonyState[i][currAge][j]; }qsort( individualMsg , colonySize , sizeof(IndividualMsg) , cmp );}//终止循环的条件bool stopFlag(){//进行n 代进行后停止static int n = 50;if( n-- <= 0 )return true;elsereturn false;}//赌轮选择int gambleChoose(){int wheel[max] = { 0 };int i = colonySize - 1;int choose;wheel[i] = individualMsg[i].value;for( i-- ; i >= 0 ; i-- )wheel[i] = ( individualMsg[i].value + wheel[i+1] ) + colonySize * ( colonySize - i ); int seed = abs( wheel[0] - ( rand() % ( 2 * wheel[0] ) + 1 ) );choose = colonySize - 1;while( seed > wheel[choose] )choose--;// cout<<"----------------------------------------"<<endl;// cout<<"wheel :"<<endl;// for( i = 0 ; i < colonySize ; i++ )// cout<<setw(5)<<wheel[i];// cout<<endl;// cout<<"seed = "<<seed<<endl;// cout<<"choose "<<choose<<endl;return choose;}//交叉void across( int male , int female , int index ){int nextAge = (currAge+1)%2;int i , j , t;int acrossBit = rand() % (packageNum-1) + 1;for( j = 0 ; j < packageNum ; j++ ){colonyState[index][nextAge][j] =colonyState[individualMsg[male].index][currAge][j];colonyState[index+1][nextAge][j] =colonyState[individualMsg[female].index][currAge][j];}for( i = 0 ; i < acrossBit ; i++ ){t = colonyState[index][nextAge][i];colonyState[index][nextAge][i] = colonyState[index+1][nextAge][i];colonyState[index+1][nextAge][j] = t;}}//变异void aberrance( int index ){int seed , nextAge;nextAge = (currAge+1)%2;//只有1/3 的概率发生异变seed = rand() % ( packageNum * 3 );if( seed < packageNum )colonyState[index][nextAge][seed] = ( colonyState[index][nextAge][seed] + 1 ) % 2;}//处理死亡个体void dealDeath(){int i , j;int weight , w;int nextAge = (currAge+1)%2;for( i = 0 ; i < colonySize ; i++ ){weight = 0;for( j = 0 ; j < packageNum ; j++ )weight += packageWeight[j] * colonyState[i][nextAge][j];if( weight > limitWeight ){//随机生成新的个体w = limitWeight + 1;while( w > limitWeight ){w = 0;for( j = 0 ; j < packageNum && w <= limitWeight ; j++ ){colonyState[i][nextAge][j] = rand() % 2;w += packageWeight[j] * colonyState[i][nextAge][j];}}}}printColonyState( nextAge );}//最优个体保护void saveBest(){int i , j;int min , minp , value;int nextAge = ( currAge+1)%2;min = individualMsg[0].value;minp = -1;for( i = 0 ; i < colonySize ; i++ ){value = 0;for( j = 0 ; j < packageNum ; j++ )value += packageValue[j] * colonyState[i][nextAge][j]; if( value <= min ){min = value;minp = i;}}if( minp >= 0 ){for( j = 0 ; j < packageNum ; j++ ){colonyState[minp][nextAge][j] =colonyState[individualMsg[0].index][currAge][j];}}}//////////////////////////////////////////////////////////// void setProblem(){int i;packageNum = 5;int w[] = { 5 , 4 , 3 , 2 , 1 };int v[] = { 8 , 9 , 3 , 1 , 2 };for( i = 0 ; i < packageNum ; i++ ){packageWeight[i] = w[i];packageValue[i] = v[i];}limitWeight = 13;colonySize = 5;}void printProblem(){int i;cout<<"----------------------------------------"<<endl;cout<<"problem state:"<<endl;cout<<"packageNum = "<<packageNum<<endl;cout<<"limitWeight = "<<limitWeight<<endl;cout<<"Weight: ";for( i = 0 ; i < packageNum ; i++ )cout<<setw(3)<<packageWeight[i];cout<<endl;cout<<"Value: ";for( i = 0 ; i < packageNum ; i++ )cout<<setw(3)<<packageValue[i];cout<<endl;}void printColonyState( int k ){cout<<"----------------------------------------"<<endl;cout<<"colonyState-->";if( k == currAge )cout<<"currAge:"<<endl;elsecout<<"next age:"<<endl;int i , j;for( i = 0 ; i < colonySize ; i++ ){for( j = 0 ; j < packageNum ; j++ )cout<<setw(2)<<colonyState[i][k][j];cout<<endl;}}void printIndividualMsg(){int i;cout<<"----------------------------------------"<<endl;cout<<"Individual Msg:"<<endl;for( i = 0 ; i < colonySize ; i++ ){cout<<individualMsg[i].index<<"\t"<<individualMsg[i].value<<endl; }}////////////////////////////////////////////////////////////void main(){srand( (unsigned int)time(NULL) );setProblem();printProblem();//初始群体colonyInit();printColonyState( currAge );while( !stopFlag() ){//评价当前群体individualEstimate();//生成下一代for( int i = 0 ; i < colonySize ; i += 2 ){int male = gambleChoose();int female = gambleChoose();across( male , female , i );aberrance( i );aberrance( i + 1 );}//处理死亡个体dealDeath();//最优个体保护saveBest();//现在的下一代变成下一轮的当前代currAge = ( currAge + 1 ) % 2;//printColonyState( currAge );}//输出问题解individualEstimate();cout<<"近似解:"<<endl;int j , w = 0;cout<<setw(10)<<"Value:";for( j = 0 ; j < packageNum ; j++ )cout<<setw(5)<<packageValue[j];cout<<endl;cout<<setw(10)<<"Weight:";for( j = 0 ; j < packageNum ; j++ ){w += packageWeight[j] * colonyState[individualMsg[0].index][currAge][j]; cout<<setw(5)<<packageWeight[j];}cout<<endl;cout<<setw(10)<<"Choose:";for( j = 0 ; j < packageNum ; j++ )cout<<setw(5)<<colonyState[individualMsg[0].index][currAge][j];cout<<endl;cout<<"limitWeight: "<<limitWeight<<endl;cout<<"总重量: "<<w<<endl;cout<<"总价值: "<<individualMsg[0].value<<endl; }////////////////////////////////////////////////////////////。

0-1背包问题(回溯法)

0-1背包问题(回溯法)

0-1背包问题(回溯法)实验报告姓名:学号:指导老师:一.算法设计名称:0-1背包问题(回溯法)二.实验内容问题描述:给定n 种物品和一背包。

物品i 的重量是w i ,其价值为v i ,背包的容量为C 。

问应如何选择装入背包的物品,使得装入背包中物品的总价值最大?在选择装入背包的物品时,对每种物品i 只有两种选择,即装入背包或不装入背包。

不能将物品装入背包多次,也不能只装入部分的物品。

三.实验目的1.运用回溯思想,设计解决上述问题的算法,找出最大背包价值的装法。

2.掌握回溯法的应用四.算法设计:问题求解思路1.由0-1背包问题的最优子结构性质,建立计算m[i][j]的递归式如下:i i i w j w j j i m i v w j i m j i m j i m <≤≥⎩⎨⎧-+---=0],1[]}[],1[],,1[max{),(2.查找装入背包物品的回溯函数:从0-1二叉树的根开始搜索:若是叶子节点,则判断此时的价值是否比当前最优的价值大,否则将之替换,并获得最优解向量且返回;若不是叶子节点,则向左右子树搜索,先改变当前的数据状态,递归的调用自己,然后恢复数据状态表示回溯。

3.边界函数bound主要是当还未搜索到叶子节点时,提前判断其子树是否存可能存在更优的解空间,否则进行回溯,即裁剪掉子树的解空间。

关键数据结构及函数模块:(Backtrack.h )#ifndef __BACKTRACK_H__#define __BACKTRACK_H__class BP_01_P{public:∑=ni i i x v 1max ⎪⎩⎪⎨⎧≤≤∈≤∑=n i x C x w i n i i i 1},1,0{1BP_01_P(int w,int n):m_Sum_weitht(0),m_Number(0) {m_Sum_weitht=w;m_Number=n;bestHav=0;bestVal=0;curVal=0;curHav=0;m_hav=new int[n];m_val=new int[n];temop=new int[n];option=new int[n];}~BP_01_P(){delete []m_hav;delete []m_val;delete []temop;delete []option;}void traceBack(int n);int bound(int n);void printBestSoulation();int *m_hav;//每个物品的重量int *m_val;//每个物品的价值int *temop;//01临时解int *option;//01最终解int bestHav;//最优价值时的最大重量int bestVal;//最优的价值int curVal;//当前的价值int curHav;//当前的重量private:int m_Sum_weitht;//背包的总容量int m_Number;//物品的种类};#endif __BACKTRACK_H__五:主要的算法代码实现:(Backtrack.cpp)边界函数:bound( )int BP_01_P::bound(int n){int hav_left=m_Sum_weitht-curHav;int bo=curVal;while(n<m_Number && m_hav[n]<=hav_left){hav_left-=m_hav[n];bo+=m_val[n];n++;}if(n<m_Number){bo+=m_val[n]*hav_left/m_hav[n];//bo+=hav_left;}return bo;}回溯递归函数:traceBack( )void BP_01_P::traceBack(int n){if(n>=m_Number){if(curVal>=bestVal){bestVal=curVal;for(int i=0;i<n;i++){option[i]=temop[i];}return ;}}if(curHav+m_hav[n]<=m_Sum_weitht)//向左子树搜索 {curHav=curHav+m_hav[n];curVal=curVal+m_val[n];temop[n]=1;//标记要选择这个物品traceBack(n+1);curHav=curHav-m_hav[n];curVal=curVal-m_val[n];}if(bound(n+1)>bestVal)//向右子树搜索{temop[n]=0;//标记要丢弃这个物品traceBack(n+1);}}主控函数:(main.cpp)#include <iostream>#include "Backtrack.h"using namespace std;int main(){int number,weigth;cout<<"包的总容量:";cin>>weigth;cout<<"物品的种类:";cin>>number;BP_01_P *ptr=new BP_01_P(weigth,number);cout<<"各种物品的重量:"<<endl;for(int i=0;i<number;i++)cin>>ptr->m_hav[i];cout<<"各种物品的价值:"<<endl;for(i=0;i<number;i++)cin>>ptr->m_val[i];ptr->traceBack(0);ptr->printBestSoulation();cout<<"总重量:"<<ptr->bestHav<<"\t总价值:"<<ptr->bestVal<<endl;return 0;}六:算法分析采用回溯法解决0-1背包问题,明显比动态规划法更优良。

0 1背包实验报告

0 1背包实验报告

0 1背包实验报告0-1背包实验报告引言:0-1背包问题是在计算机科学中经典的组合优化问题之一。

该问题的目标是在给定一组物品和一个固定容量的背包下,选择一些物品放入背包中,使得放入的物品总价值最大化,同时不能超过背包的容量限制。

本实验旨在通过实际操作和数据分析,深入理解0-1背包问题的求解方法和优化策略。

实验设计:本实验采用Python编程语言进行0-1背包问题的求解。

首先,我们设计了一个物品类(Item),每个物品具有重量(weight)和价值(value)两个属性。

然后,我们生成了一组具有不同重量和价值的物品,这些物品将作为输入数据用于求解0-1背包问题。

接下来,我们实现了两种常见的求解方法:动态规划和贪心算法,并对它们的性能进行了对比分析。

实验过程:1. 生成输入数据:我们使用随机数生成器生成了一组具有不同重量和价值的物品。

为了方便观察和分析,我们限定了物品的数量为10个,重量范围为1到10,价值范围为1到100。

2. 动态规划求解:动态规划是解决0-1背包问题的经典方法之一。

我们设计了一个动态规划函数,通过填充一个二维数组来求解最优解。

具体步骤如下:- 初始化一个二维数组dp,其中dp[i][j]表示在前i个物品中选择总重量不超过j的物品的最大总价值。

- 通过递推公式dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]] + value[i])求解dp数组。

- 根据dp数组的最后一行最后一列的值,反推出背包中放入的物品。

3. 贪心算法求解:贪心算法是另一种常见的求解0-1背包问题的方法。

它的基本思想是每次选择具有最大单位价值的物品放入背包中,直到背包无法再放入任何物品为止。

具体步骤如下:- 计算每个物品的单位价值(value/weight)。

- 按照单位价值从大到小的顺序对物品进行排序。

- 依次选择单位价值最大的物品放入背包中,直到背包无法再放入任何物品。

0-1背包问题求解方法综述

0-1背包问题求解方法综述

算法分析与设计大作业实验题目:0-1背包问题求解方法综述组员:班级:指导老师:0-1背包问题求解方法综述【摘要】:0-1背包问题是一个经典的NP-hard组合优化问题,现实生活中的很多问题都可以以它为模型。

本文首先对背包问题做了阐述,然后用蛮力解法、动态规划算法、贪心算法和回溯解法对背包问题进行求解,分析了0-1背包问题的数学模型,刻划了最优解的结构特征,建立了求最优值的递归关系式。

最后对四种算法从不同角度进行了对比和总结。

【关键词】:0-1背包问题;蛮力解法;动态规划算法;贪心算法;回溯解法。

0.引言0-1背包问题是指给定n个物品,每个物品均有自己的价值vi和重量wi(i=1,2,…,n),再给定一个背包,其容量为W。

要求从n个物品中选出一部分物品装入背包,这部分物品的重量之和不超过背包的容量,且价值之和最大。

单个物品要么装入,要么不装入。

很多问题都可以抽象成该问题模型,如配载问题、物资调运[1]问题等,因此研究该问题具有较高的实际应用价值。

目前,解决0-1背包问题的方法有很多,主要有动态规划法、回溯法、分支限界法、遗传算法、粒子群算法、人工鱼群算法、蚁群算法、模拟退火算法、蜂群算法、禁忌搜索算法等。

其中动态规划、回溯法、分支限界法时间复杂性比较高,计算智能算法可能出现局部收敛,不一定能找出问题的最优解。

文中在动态规划法的基础上进行了改进,提出一种求解0-1背包问题的算法,该算法每一次执行总能得到问题的最优解,是确定性算法,算法的时间复杂性最坏可能为O(2n)。

1.0-1背包问题描述0-1背包问题(KP01)是一个著名的组合优化问题。

它应用在许多实际领域,如项目选择、资源分布、投资决策等。

背包问题得名于如何选择最合适的物品放置于给定背包中。

本文主要研究背包问题中最基础的0/1背包问题的一些解决方法。

为解决背包问题,大量学者在过去的几十年中提出了很多解决方法。

解决背包问题的算法有最优算法和启发式算法[2],最优算法包括穷举法、动态规划法、分支定界法、图论法等,启发式算法包括贪心算法、遗传算法、蚁群算法、粒子算法等一些智能算法。

贪心算法实现背包问题算法设计与分析实验报告

贪心算法实现背包问题算法设计与分析实验报告

算法设计与分析实验报告实验名称贪心算法实现背包问题评分实验日期年月日指导教师姓名专业班级学号一.实验要求1. 优化问题有n个输入,而它的解就由这n个输入满足某些事先给定的约束条件的某个子集组成,而把满足约束条件的子集称为该问题的可行解。

可行解一般来说是不唯一的。

那些使目标函数取极值(极大或极小)的可行解,称为最优解。

2.贪心法求优化问题算法思想:在贪心算法中采用逐步构造最优解的方法。

在每个阶段,都作出一个看上去最优的决策(在一定的标准下)。

决策一旦作出,就不可再更改。

作出贪心决策的依据称为贪心准则(greedy criterion)。

3.一般方法1)根据题意,选取一种量度标准。

2)按这种量度标准对这n个输入排序3)依次选择输入量加入部分解中。

如果当前这个输入量的加入,不满足约束条件,则不把此输入加到这部分解中。

procedure GREEDY(A,n) /*贪心法一般控制流程*///A(1:n)包含n个输入//solutions←φ //将解向量solution初始化为空/for i←1 to n dox←SELECT(A)if FEASIBLE(solution,x)then solutions←UNION(solution,x)endifrepeatreturn(solution)end GREEDY4. 实现典型的贪心算法的编程与上机实验,验证算法的时间复杂性函数。

二.实验内容1. 编程实现背包问题贪心算法。

通过具体算法理解如何通过局部最优实现全局最优,并验证算法的时间复杂性。

2.输入5个的图的邻接矩阵,程序加入统计prim算法访问图的节点数和边数的语句。

3.将统计数与复杂性函数所计算比较次数比较,用表格列出比较结果,给出文字分析。

三.程序算法1.背包问题的贪心算法procedure KNAPSACK(P,W,M,X,n)//P(1:n)和W(1;n)分别含有按P(i)/W(i)≥P(i+1)/W(i+1)排序的n件物品的效益值和重量。

0-1背包问题的递归方法

0-1背包问题的递归方法

0-1背包问题的递归方法0-1背包问题是一个经典的动态规划问题,可以使用递归方法求解。

定义一个函数`knapsack(weights, values, capacity, n)`,其中`weights`和`values`分别代表物品的重量和价值,`capacity`代表背包的容量,`n`代表当前考虑的物品个数。

递归的思路是对于每个物品,有两种选择:放入背包中或者不放入背包中。

1. 如果第`n`个物品的重量大于背包的容量`capacity`,则不放入背包中,返回`0`;2. 否则,有两种选择:- 选择放入第`n`个物品,则总价值为第`n`个物品的价值加上考虑前`n-1`个物品,背包容量减去第`n`个物品重量的最优解; - 不放入第`n`个物品,则总价值为考虑前`n-1`个物品,背包容量不变的最优解。

代码如下所示:```pythondef knapsack(weights, values, capacity, n):if n == 0 or capacity == 0:return 0if weights[n-1] > capacity:return knapsack(weights, values, capacity, n-1)else:return max(values[n-1] + knapsack(weights, values, capacity-weights[n-1], n-1),knapsack(weights, values, capacity, n-1))```可以通过调用`knapsack`函数来求解0-1背包问题,如下所示:```pythonweights = [2, 3, 4, 5]values = [3, 4, 5, 6]capacity = 5n = len(weights)result = knapsack(weights, values, capacity, n)print(result)```以上代码会输出最优解的总价值。

背包问题问题实验报告(3篇)

背包问题问题实验报告(3篇)

第1篇一、实验目的1. 理解背包问题的基本概念和分类。

2. 掌握不同背包问题的解决算法,如0-1背包问题、完全背包问题、多重背包问题等。

3. 分析背包问题的复杂度,比较不同算法的效率。

4. 通过实验验证算法的正确性和实用性。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.73. 开发工具:PyCharm4. 实验数据:随机生成的背包物品数据三、实验内容1. 0-1背包问题(1)问题描述:给定n个物品,每个物品的重量为w[i],价值为v[i],背包的容量为C。

求将哪些物品装入背包,使得背包内物品的总价值最大。

(2)解决算法:动态规划法(3)实验步骤:a. 初始化一个二维数组dp[n+1][C+1],其中dp[i][j]表示前i个物品在容量为j 的背包中的最大价值。

b. 遍历每个物品,对于每个容量,根据物品的重量和价值计算dp值。

c. 返回dp[n][C],即为最大价值。

2. 完全背包问题(1)问题描述:给定n个物品,每个物品的重量为w[i],价值为v[i],背包的容量为C。

求将哪些物品装入背包,使得背包内物品的总价值最大,且每个物品可以重复取。

(2)解决算法:动态规划法(3)实验步骤:a. 初始化一个一维数组dp[C+1],其中dp[j]表示容量为j的背包的最大价值。

b. 遍历每个物品,对于每个容量,根据物品的重量和价值更新dp值。

c. 返回dp[C],即为最大价值。

3. 多重背包问题(1)问题描述:给定n个物品,每个物品的重量为w[i],价值为v[i],背包的容量为C。

每个物品有无限个,求将哪些物品装入背包,使得背包内物品的总价值最大。

(2)解决算法:动态规划法(3)实验步骤:a. 初始化一个一维数组dp[C+1],其中dp[j]表示容量为j的背包的最大价值。

b. 遍历每个物品,对于每个容量,根据物品的重量和价值更新dp值。

c. 返回dp[C],即为最大价值。

四、实验结果与分析1. 0-1背包问题实验结果显示,在背包容量为100时,最大价值为298。

部分背包问题的贪心算法正确性证明

部分背包问题的贪心算法正确性证明

部分背包问题的贪⼼算法正确性证明⼀,部分背包问题介绍⾸先介绍下0-1背包问题。

假设⼀共有N件物品,第 i 件物品的价值为 V i,重量为W i,⼀个⼩偷有⼀个最多只能装下重量为W的背包,他希望带⾛的物品越有价值越好,请问:他应该选择哪些物品?0-1背包问题的特点是:对于某件(更适合的说法是:某类)物品,要么被带⾛(选择了它),要么不被带⾛(没有选择它),不存在只带⾛⼀部分的情况。

⽽部分背包问题则是:可以带⾛⼀部分。

即,部分背包问题可带⾛的物品是可以⽆限细分的。

(连续与离散的区别)可以把0-1背包问题中的物品想象的⼀个⾦⼦,你要么把它带⾛,要么不带⾛它;⽽部分背包问题中的物品则是⼀堆⾦粉末,可以取任意部分的⾦粉末⼆,部分背包问题的贪⼼算法部分背包问题可以⽤贪⼼算法求解,且能够得到最优解。

贪⼼策略是什么呢?将物品按单位重量所具有的价值排序。

总是优先选择单位重量下价值最⼤的物品。

单位重量所具有的价值:V i / W i举个例⼦:假设背包可容纳50Kg的重量,物品信息如下:物品 i 重量(Kg) 价值单位重量的价值1 10 60 62 20 100 53 30 120 4按照我们的贪⼼策略,单位重量的价值排序:物品1 > 物品2 > 物品3因此,我们尽可能地多拿物品1,直到将物品1拿完之后,才去拿物品2.....最终贪⼼选择的结果是这样的:物品1全部拿完,物品2也全部拿完,物品3拿⾛10Kg(只拿⾛了物品3的⼀部分)这种选择获得的价值是最⼤的。

在(三)会给出证明。

⽽对于0-1背包问题,如果也按“优先选择单位重量下价值最⼤的物品”这个贪⼼策略,那么,在拿了物品1和物品2之后,就不能在拿物品3了。

因为,在拿了物品1和物品2之后,背包中已经装了10+20=30Kg的物品了,已经装不下物品3了(50-30 < 30)(0-1背包:⼀件物品要么拿,要么不拿,否能只拿⼀部分),此时得到的总价值是 160。

0-1背包问题(分支限界法)

0-1背包问题(分支限界法)

分支限界法——01背包问题12软工028 胡梦颖一、问题描述0-1背包问题:给定n种物品和一个背包。

物品i的重量是Wi,其价值为Vi,背包的容量为C。

应如何选择装入背包的物品,使得装入背包中物品的总价值最大?在选择装入背包的物品时,对每种物品i只有2种选择,即装入背包或不装入背包。

不能将物品i装入背包多次,也不能只装入部分的物品i。

二、问题分析分支限界法类似于回溯法,也是在问题的解空间上搜索问题解的算法。

一般情况下,分支限界法与回溯法的求解目标不同。

回溯法的求解目标是找出解空间中满足约束条件的所有解,而分支限界法的求解目标则是找出满足约束条件的一个解,或是在满足约束条件的解中找出使某一目标函数值达到极大或极小的解,即在某种意义下的最优解。

由于求解目标不同,导致分支限界法与回溯法对解空间的搜索方式也不相同。

回溯法以深度优先的方式搜索解空间,而分支限界法则以广度优先或以最小耗费优先的方式搜索解空间。

分支限界法的搜索策略是,在扩展结点处,先生成其所有的儿子结点(分支),然后再从当前的活结点表中选择下一扩展结点。

为了有效地选择下一扩展结点,加速搜索的进程,在每一个活结点处,计算一个函数值(限界),并根据函数值,从当前活结点表中选择一个最有利的结点作为扩展结点,使搜索朝着解空间上有最优解的分支推进,以便尽快地找出一个最优解。

这种方式称为分支限界法。

人们已经用分支限界法解决了大量离散最优化的问题。

三.源代码#include <stdio.h>#include<malloc.h>#define MaxSize 100 //结点数的最大值typedef struct QNode{float weight;float value;int ceng;struct QNode *parent;bool leftChild;}QNode,*qnode;typedef struct{qnode Q[MaxSize];int front,rear;}SqQueue; //存放结点的队列SqQueue sq;float bestv=0; //最优解int n=0; //实际物品数float w[MaxSize]; //物品的重量float v[MaxSize]; //物品的价值int bestx[MaxSize]; // 存放最优解qnode bestE;void InitQueue(SqQueue &sq ) //队列初始化{sq.front=1;sq.rear=1;}bool QueueEmpty(SqQueue sq) //队列是否为空{if(sq.front==sq.rear)return true;elsereturn false;}void EnQueue(SqQueue &sq,qnode b) //入队{if(sq.front==(sq.rear+1)%MaxSize){printf("队列已满!");return;}sq.Q[sq.rear]=b;sq.rear=(sq.rear+1)%MaxSize;} qnode DeQueue(SqQueue &sq) //出队{qnode e;if(sq.front==sq.rear){printf("队列已空!");return 0;}e=sq.Q[sq.front];sq.front=(sq.front+1)%MaxSize;return e;}void EnQueue1(float wt,float vt, int i ,QNode *parent, bool leftchild) {qnode b;if (i==n) //可行叶子结点{ if (vt==bestv){ bestE=parent;bestx[n]=(leftchild)?1:0;}return;}b=(qnode)malloc(sizeof(QNode)); //非叶子结点b->weight=wt;b->value=vt;b->ceng=i;b->parent=parent;b->leftChild=leftchild;EnQueue(sq,b);}void maxLoading(float w[],float v[],int c){float wt=0;float vt=0;int i=1; //当前的扩展结点所在的层float ew=0; //扩展节点所相应的当前载重量float ev=0; //扩展结点所相应的价值qnode e=NULL;qnode t=NULL;InitQueue(sq);EnQueue(sq,t); //空标志进队列while (!QueueEmpty(sq)){wt=ew+w[i];vt=ev+v[i];if (wt <= c){if(vt>bestv)bestv=vt;EnQueue1(wt,vt,i,e,true); // 左儿子结点进队列} EnQueue1(ew,ev,i,e,false); //右儿子总是可行;e=DeQueue(sq); // 取下一扩展结点if (e == NULL){if (QueueEmpty(sq))break;EnQueue(sq,NULL); // 同层结点尾部标志e=DeQueue(sq); // 取下一扩展结点i++;}ew=e->weight; //更新当前扩展结点的值ev=e->value;}printf("最优取法为:\n");for( int j=n-1;j>0;j--) //构造最优解{bestx[j]=(bestE->leftChild?1:0);bestE=bestE->parent;}for(int k=1;k<=n;k++){if(bestx[k]==1)printf("物品%d:重量:%.1f,价值:%.1f\n",k,w[k],v[k]);}printf("最大价值为:%.1f\n",bestv);}void main(){int c;float ewv[MaxSize];printf("请输入背包的最大容量v:");scanf("%d",&c);printf("请输入物品总数n:");scanf("%d",&n);printf("请输入物品的重量和单位重量价值:\n");for(int i=1;i<=n;i++){printf("第%d件物品:",i);scanf("%f%f",&w[i],&ewv[i]);v[i]=w[i]*ewv[i];}maxLoading(w,v,c);}五.实验结果。

贪心算法求解背包问题C语言描述

贪心算法求解背包问题C语言描述

贪心算法求解背包问题:#include<stdio.h>#define maxnumber 20typedef struct node{float w;float v;int i;}Object;float find(Object wp[],int n,float M) {float x[maxnumber];int i;float maxprice=0;for(i=1;i<=n;i++)//初始化x[n];{x[i]=0.0;}i=0;while(wp[i].w < M){x[wp[i].i]=1;M=M-wp[i].w;i++;}x[wp[i].i]=M/wp[i].w;//输出解向量printf("解向量是:\n");for(i=1;i<=n;i++){printf("x[%d]=%f",i,x[i]);}printf("\n");//计算最大价值for(i=0;i<n;i++){maxprice=maxprice+wp[i].v*x[wp[i].i];}return maxprice;}void main(){Object wp[maxnumber];int i,j,n;float C;//背包的重量int flag;float maxprice,temp;printf("请输入物品的种数:");scanf("%d",&n);printf("请输入背包的重量:");scanf("%f",&C);printf("\n请输入物品的序号、重量和价值:");for(i=0;i<n;i++){scanf("%d",&wp[i].i);scanf("%f",&wp[i].w);scanf("%f",&wp[i].v);}printf("\n输入的物品是:\n");//输出物品for(i=0;i<n;i++){printf(" %d",wp[i].i);printf(" %f",wp[i].w);printf(" %f",wp[i].v);printf("\n");}//用冒泡排序对物品按照单位价值进行降序排序for(i=1;i<n;i++){flag=0;for(j=n-1;j>=i;j--){if(wp[j-1].v/wp[j-1].w < wp[j].v/wp[j].w){temp=wp[j-1].i;wp[j-1].i=wp[j].i;wp[j].i=temp;temp=wp[j-1].w;wp[j-1].w=wp[j].w;wp[j].w=temp;temp=wp[j-1].v;wp[j-1].v=wp[j].v;wp[j].v=temp;flag=1;}if(flag==0)break;}}printf("\n排序后的物品是:\n");//输出物品for(i=0;i<n;i++){printf(" %d",wp[i].i);printf(" %f",wp[i].w);printf(" %f",wp[i].v);printf("\n");}maxprice=find(wp,n,C);printf("\n物品的重价值为:%f",maxprice);}。

C语言版贪心算法背包问题

C语言版贪心算法背包问题

C语言版贪心算法背包问题#include#define N 100typedef struct bao{int num;float w;float v;};typedef struct avg{int num;float val;float w;float v;};struct bao b[N];struct avg d[N];int n;float c;void Sort(){int i,j,k;struct avg temp[N];for(i=0;i<n-1;i++)< p="">{k = i;for(j=i+1;j<n;j++)< p="">if(d[k].valif(k != i){temp[i]=d[i];d[i]=d[k];d[k]=temp[i];}}}float knapsack(){int i;float x[N],sum = 0;for(i=0;ifor(i=0;i<n;i++){< p="">if(d[i].w>c) break;x[d[i].num] = 1;sum += d[i].v;c -= d[i].w;}if(i<n){< p="">x[d[i].num] = c/d[i].w;sum += x[d[i].num] * d[i].v;}return sum;}int main(){int i,j,k;float sum;printf("请输入物品总数:");scanf("%d",&n);printf("\n请输入背包容量:");scanf("%f",&c);printf("\n请输入各物品重量及价值(格式:xx,xx):");for(i=0;i<n;i++){< p=""> scanf("%f,%f",&b[i].w,&b[i].v); }for(i=0;i<="" p="">for(i=0;i<n;i++){< p="">d[i].val = b[i].v/b[i].w;d[i].v = b[i].v;d[i].w = b[i].w;}Sort();sum = knapsack();printf("%.2f\n",sum);}</n;i++){<></n;i++){<></n){<></n;i++){<></n;j++)<></n-1;i++)<>。

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