C语言版贪心算法背包问题
贪心算法补充背包问题
void Insertionsort(goodinfo goods[],int n) {//插入排序，按pi/wi价值收益进行排序，一般教材 {//插入排序 插入排序， pi/wi价值收益进行排序 价值收益进行排序， 上按冒泡排序 int j,i; for(j=2;j<=n;j++) { goods[0]=goods[j]; i=j-1; i=jwhile (goods[0].p>goods[i].p) { goods[i+1]=goods[i]; i--; --; } goods[i+1]=goods[0]; } }//按物品效益，重量比值做升序排列 }//按物品效益 按物品效益，
引言
顾名思义，贪心算法总是作出在当前看来 顾名思义，贪心算法总是作出在当前看来 最好的选择。也就是说贪心算法并不从整 体最优考虑，它所作出的选择只是在某种 意义上的局部最优选择。当然，希望贪心 意义上的局部最优选择。当然，希望贪心 算法得到的最终结果也是整体最优的。虽 然贪心算法不能对所有问题都得到整体最 优解，但对许多问题它能产生整体最优解。 如单源最短路经问题，最小生成树问题等。 在一些情况下，即使贪心算法不能得到整 体最优解，其最终结果却是最优解的很好 近似。
Hale Waihona Puke 贪心算法解决背包问题的算法实现： 贪心算法解决背包问题的算法实现：
#include <iostream.h> struct goodinfo { float p; //物品效益 float w; //物品重量 float X; //物品该放的 数量 int flag; //物品编号 };//物品信息结构体
贪心算法解决背包问题有几种策略： 贪心算法解决背包问题有几种策略： (i) 一种贪婪准则为：从剩余的物品中，选出可以装入背包的价值最 大的物品，利用这种规则，价值最大的物品首先被装入（假设有足够 容量），然后是下一个价值最大的物品，如此继续下去。这种策略不 能保证得到最优解。例如，考虑n=2, w=[100,10,10], p =[20,15,15], 能保证得到最优解。例如，考虑n=2, c = 105。当利用价值贪婪准则时，获得的解为x= [ 1 , 0 , 0 ]，这 105。当利用价值贪婪准则时，获得的解为x= ]，这 种方案的总价值为2 0。而最优解为[ 种方案的总价值为2 0。而最优解为[ 0 , 1 , 1 ]，其总价值为3 0。 ]，其总价值为3 0。 (ii) 另一种方案是重量贪婪准则是：从剩下的物品中选择可装入背包 的重量最小的物品。虽然这种规则对于前面的例子能产生最优解，但 在一般情况下则不一定能得到最优解。考虑n= 在一般情况下则不一定能得到最优解。考虑n= 2 ,w=[10,20], p=[5,100], c= 2 5。当利用重量贪婪策略时，获得的解为x =[1,0], 5。当利用重量贪婪策略时，获得的解为x 比最优解[ 比最优解[ 0 , 1 ]要差。 ]要差。 (iii) 还有一种贪婪准则，就是我们教材上提到的，认为，每一项计 算yi=vi/si,即该项值和大小的比，再按比值的降序来排序，从第一项 yi=vi/si,即该项值和大小的比，再按比值的降序来排序，从第一项 开始装背包，然后是第二项，依次类推，尽可能的多放，直到装满背 包。 有的参考资料也称为价值密度pi/wi贪婪算法。这种策略也不能保证得 有的参考资料也称为价值密度pi/wi贪婪算法。这种策略也不能保证得 到最优解。利用此策略试解n= 到最优解。利用此策略试解n= 3 ,w=[20,15,15], p=[40,25,25], c=30 时的最优解。虽然按pi /wi 非递（增）减的次序装入物品不能 时的最优解。虽然按pi 保证得到最优解，但它是一个直觉上近似的解。 而且这是解决普通背包问题的最优解，因为在选择物品i 而且这是解决普通背包问题的最优解，因为在选择物品i装入背包时， 可以选择物品i的一部分，而不一定要全部装入背包，1≤i≤n。 可以选择物品i的一部分，而不一定要全部装入背包，1≤i≤n。
c语言-01背包问题
c语⾔-01背包问题01背包问题问题：有N件物品和⼀个容量为V的背包。
第i件物品的费⽤是c[i]，价值是w[i]。
求解将哪些物品装⼊背包可使价值总和最⼤。
分析：这是最基础的背包问题，特点是：每种物品仅有⼀件，可以选择放或不放。
⽤⼦问题定义状态：即f[i][v]表⽰前i件物品恰放⼊⼀个容量为v的背包可以获得的最⼤价值。
则其状态转移⽅程便是：f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}这个⽅程⾮常重要，基本上所有跟背包相关的问题的⽅程都是由它衍⽣出来的。
所以有必要将它详细解释⼀下：“将前i件物品放⼊容量为v的背包中”这个⼦问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为⼀个只牵扯前i-1件物品的问题。
如果不放第i件物品，那么问题就转化为“前i-1件物品放⼊容量为v的背包中”，价值为f[i-1][v]；如果放第i件物品，那么问题就转化为“前i-1件物品放⼊剩下的容量为v-c[i]的背包中”，此时能获得的最⼤价值就是f[i-1][v-c[i]]再加上通过放⼊第i件物品获得的价值w[i]。
优化：以上⽅法的时间和空间复杂度均为O(VN)，其中时间复杂度应该已经不能再优化了，但空间复杂度却可以优化到O。
先考虑上⾯讲的基本思路如何实现，肯定是有⼀个主循环i=1..N，每次算出来⼆维数组f[i][0..V]的所有值。
那么，如果只⽤⼀个数组 f[0..V]，能不能保证第i次循环结束后f[v]中表⽰的就是我们定义的状态f[i][v]呢？f[i][v]是由f[i-1][v]和f[i-1] [v-c[i]]两个⼦问题递推⽽来，能否保证在推f[i][v]时（也即在第i次主循环中推f[v]时）能够得到f[i-1][v]和f[i-1] [v-c[i]]的值呢？事实上，这要求在每次主循环中我们以v=V..0的顺序推f[v]，这样才能保证推f[v]时f[v-c[i]]保存的是状态 f[i-1][v-c[i]]的值。
背包问题解析（一）-贪心算法
背包问题解析（⼀）-贪⼼算法⼀、题⽬:有N件物品和⼀个容量为V的背包。
第i件物品的重量是w[i]，价值是v[i]。
求解将哪些物品装⼊背包可使这些物品的重量总和不超过背包容量，且价值总和最⼤。
⼆、解决思路:本题刚开始的解题的时候,想采取贪⼼算法来解决,也就是将放⼊的物品的性价⽐按照从⾼到低进⾏排序，然后优先放优先级⾼的，其次优先级低的。
三、代码实现（python）1# 重量w=[5,4,3,2]2# 价值v=[6,5,4,3]3 b=[]4 m=int(input("请输⼊背包的最⼤重量:"))5 n=int(input("请输⼊商品的数量:"))6for i in range(n):7 a=input("请分别输⼊重量和价值,以空格隔开:")8 a=a.split("")9for i in range(len(a)):10 a[i]=int(a[i])11 b.append(a)12print("加载初始化:",b)13for i in range(len(b)):14for j in range(i+1,len(b)):15if b[i][1]/b[i][0]<b[j][1]/b[j][0]:16 b[i],b[j]=b[j],b[i]17print("性价⽐排序:",b)18 v=019 c=[]20for i in range(len(b)):21if m-b[i][0]>0:22 m=m-b[i][0]23 c.append(b[i])24 v+=b[i][1]25print("放⼊背包:",c)26print("最⼤价值为:",v)打印结果：四、算法分析：贪⼼选择是指所求问题的整体最优解可以通过⼀系列局部最优的选择，即贪⼼选择来达到。
动态规划------背包问题（c语言）
动态规划------背包问题（c语⾔）/*背包问题:背包所能容纳重量为10；共五件商品，商品重量⽤数组m存储m[5]={2,2,6,5,4},每件商品的价值⽤数组n存储,n[5]={6,3,5,4,6};求背包所能装物品的最⼤价值。
*/#include<stdio.h>#include<conio.h>int main() {int m[5] = { 2,2,6,5,4 }, n[5] = { 6,3,5,4,6 };int flag[5] = { 0,0,0,0,0 };//符号标志位，表⽰地某个点是否装⼊背包，装⼊为1，未装⼊为0；int i, j, k;int c = 10, sum1 = 0, sum2 = 0;//sum1表⽰最终背包容纳的重量。
sum2表⽰最终背包中容纳的最⼤价值的价值。
//设⼀个⼆维数组，横坐标表⽰所装物品的标号，纵坐标表⽰背包所容纳的最⼤重量0~10；int mn[5][11];for (i = 4; i >= 0; i--) {//⼆维数组从下⾄上for (j = 0; j <= 10; j++) {if (i == 4) {if (m[i]>j)mn[i][j] = 0;elsemn[i][j] = n[i];}else {if (m[i]>j) {mn[i][j] = mn[i + 1][j];}else {mn[i][j] = mn[i + 1][j]>mn[i + 1][j - m[i]] + n[i] ? mn[i + 1][j] : mn[i + 1][j - m[i]] + n[i];}}}}for (i = 0; i<5; i++) {if (mn[i][c] != mn[i + 1][c]) {//从⼆维数组上⽅开始，背包最⼤值c,mn[i][c]的值若与mn[i+1][c]的值不同，则m[i]未放⼊背包中（之前是⾃下往上放的） flag[i] = 1;c = c - m[i];//若放⼊背包，则背包可容纳总重量减少；}printf("%d ", flag[i]);}//输出所放⼊的物品序号for (i = 0; i<5; i++) {if (flag[i] == 1) {sum1 += m[i];sum2 += n[i];}}printf("\n背包容纳的重量为：%d 背包容纳的总价值为：%d", sum1, sum2);getch();return0;}。
背包问题的贪心算法
贪心方法：总是对当前的问题作最好的选择，也就是局部寻优。
最后得到整体最优。
应用：1：该问题可以通过“局部寻优”逐步过渡到“整体最优”。
贪心选择性质与“动态规划”的主要差别。
2：最优子结构性质：某个问题的整体最优解包含了“子”问题的最优解。
代码如下：#include <iostream.h>struct goodinfo{float p; //物品效益float w; //物品重量float X; //物品该放的数量int flag; //物品编号};//物品信息结构体void Insertionsort(goodinfo goods[],int n){int j,i;for(j=2;j<=n;j++){goods[0]=goods[j];i=j-1;while (goods[0].p>goods[i].p){goods[i+1]=goods[i];i--;}goods[i+1]=goods[0];}}//按物品效益，重量比值做升序排列void bag(goodinfo goods[],float M,int n){float cu;int i,j;for(i=1;i<=n;i++)goods[i].X=0;cu=M; //背包剩余容量for(i=1;i<n;i++){if(goods[i].w>cu)//当该物品重量大与剩余容量跳出break;goods[i].X=1;cu=cu-goods[i].w;//确定背包新的剩余容量}if(i<=n)goods[i].X=cu/goods[i].w;//该物品所要放的量/*按物品编号做降序排列*/for(j=2;j<=n;j++){goods[0]=goods[j];i=j-1;while (goods[0].flag<goods[i].flag){goods[i+1]=goods[i];i--;}goods[i+1]=goods[0];}/////////////////////////////////////////// cout<<"最优解为:"<<endl;for(i=1;i<=n;i++){cout<<"第"<<i<<"件物品要放:";cout<<goods[i].X<<endl;}}Insertionsort(goods,n);bag(goods,M,n);cout<<"press <1> to run agian"<<endl;cout<<"press <0> to exit"<<endl;cin>>j;}}#include<stdio.h>#include<stdlib.h>#define Max 100/*定义栈结构*/typedef struct list{ int data[Max]; int top;}Seqstack; /*定义一个用来存储结果的链表*/typedef struct List{ Seqstack result; struct List * Next;} Seqlist,*Pointer;void Inicial_List(Pointer p){ p=(Pointer)malloc(sizeof(Seqlist));p->Next=NULL;}Seqstack Push_Stack(int n,Seqstack s){ s.top++;s.data[s.top]=n;return s;}int Add_Stack(Seqstack s){Int total=0,i;if(s.top>=0){ for(i=0;i<=s.top;i++)total+=s.data[i];}else{ total=0; }return total;}Seqstack Pop_Stack(Seqstack s){printf("%d",s.data[s.top]);if(s.top>=0)s.top--;return s;}/*执行回溯操作的函数*//*参数说明：n->数的总的个数，a[]用来存放数的数组,k查找的总体积*/Pointer Query_Result(int n,int b[],int k){ int i,j;Seqstack mystack;Seqlist *newnode;Pointer r,p=NULL;Inicial_List(p);r=p; for(i=0;i<n;i++){ mystack.top=-1;j=i;while(j<n){if(Add_Stack(mystack)+b[j]<k){ mystack=Push_Stack(b[j],mystack);j++; }else if(Add_Stack(mystack)+b[j]==k){ mystack=Push_Stack(b[j],mystack);newnode=(Pointer)malloc(sizeof(Seqlist));newnode->result=mystack;newnode->Next=NULL;r->Next=newnode;r=newnode;mystack=Pop_Stack(mystack);j++;else if(Add_Stack(mystack)+b[j]>k){j++;}}}return p;}void Print_List(Pointer p){int i,j=0;p=p->Next;printf("welcome the outer\n");if(p==NULL)printf("there no results\n");while(p!=NULL){j++;printf("the %d result is: ",j);for(i=0;i<=p->result.top;i++){ printf(" %d",p->result.data[i]);}p=p->Next;printf("\n"); }printf("\n");}void Sort_Array(int b[],int n){int i,j,temp;for(i=0;i<n;i++){ for(j=0;j<n-i;j++){ if(b[j]<b[j+1]){ temp=b[j];b[j]=b[j+1];b[j+1]=temp;}}}}void main(){int i,n,k,select,a[Max];Pointer head;printf("******************************************\n"); printf("1 start\n2 exit\n"); scanf("%d",&select);while(select==1)printf("please input the total products\n");scanf("%d",&n);printf("please input the volumn of n products\n");for(i=0;i<n;i++){printf("please input the %d integers",i+1);scanf("%d",&a[i]);}printf("\n");printf("please input the volunm to put\n");scanf("%d",&k);Sort_Array(a,n);head=Query_Result(n,a,k);Print_List(head);printf("******************************************\n"); printf("1 start\n2 exit\n"); scanf("%d",&select);}}#include<stdio.h>#include<stdlib.h>#define Max 100/*定义栈结构*/typedef struct list{ int data[Max]; int top;}Seqstack;/*定义一个用来存储结果的链表*/typedef struct List{Seqstack result;struct List * Next;}Seqlist,*Pointer;void Inicial_List(Pointer p){p=(Pointer)malloc(sizeof(Seqlist));p->Next=NULL;}Seqstack Push_Stack(int n,Seqstack s){ s.top++;s.data[s.top]=n;return s;}int Add_Stack(Seqstack s){ int total=0,i;if(s.top>=0){for(i=0;i<=s.top;i++)total+=s.data[i];}else{total=0;}return total;}Seqstack Pop_Stack(Seqstack s){printf("%d",s.data[s.top]);if(s.top>=0)s.top--; return s;}/*执行回溯操作的函数*//*参数说明：n->数的总的个数，a[]用来存放数的数组,k查找的总体积*/ Pointer Query_Result(int n,int b[],int k){int i,j;Seqstack mystack;Seqlist *newnode;Pointer r,p=NULL;Inicial_List(p);r=p;for(i=0;i<n;i++){mystack.top=-1;j=i;while(j<n){if(Add_Stack(mystack)+b[j]<k){mystack=Push_Stack(b[j],mystack);j++;}else if(Add_Stack(mystack)+b[j]==k){mystack=Push_Stack(b[j],mystack);newnode=(Pointer)malloc(sizeof(Seqlist));newnode->result=mystack;newnode->Next=NULL;r->Next=newnode;r=newnode;mystack=Pop_Stack(mystack);j++;}else if(Add_Stack(mystack)+b[j]>k){j++;}}}return p;}void Print_List(Pointer p){int i,j=0;p=p->Next;printf("welcome the outer\n");if(p==NULL)printf("there no results\n");while(p!=NULL){j++;printf("the %d result is: ",j);for(i=0;i<=p->result.top;i++){printf(" %d",p->result.data[i]);}p=p->Next;printf("\n");}printf("\n");}void Sort_Array(int b[],int n){int i,j,temp;for(i=0;i<n;i++) { for(j=0;j<n-i;j++){if(b[j]<b[j+1]){temp=b[j];b[j]=b[j+1];b[j+1]=temp;}}}}void main(){int i,n,k,select,a[Max]; Pointer head;printf("******************************************\n"); printf("1 start\n2 exit\n"); scanf("%d",&select);while(select==1){printf("please input the total products\n");scanf("%d",&n);printf("please input the volumn of n products\n");for(i=0;i<n;i++){printf("please input the %d integers",i+1);scanf("%d",&a[i]); } printf("\n");printf("please input the volunm to put\n");scanf("%d",&k); Sort_Array(a,n);head=Query_Result(n,a,k);Print_List(head);printf("******************************************\n"); printf("1 start\n2 exit\n");scanf("%d",&select);}}。
贪心法解决背包问题
算法分析实验报告贪心法解决背包问题学生姓名：专业：班级：学号:指导教师：2017年6月12日目录一、实验题目 (2)二、实验目的 (2)三、实验要求 (2)四、实现过程 (3)1、实验设计： (3)2、调试分析 (5)3、运行结果： (6)4、实验总结： (6)五、参考文献 (6)一、实验题目贪心法解决背包问题二、实验目的1）以背包问题为例，掌握贪心法的基本设计策略。
2）熟练掌握各种贪心策略情况下的背包问题的算法并实现；其中：量度标准分别取：效益增量v、物品重量w、v/ w比值；3) 分析实验结果来验证理解贪心法中目标函数设计的重要性。
三、实验要求1.[问题描述]：给定n种物品和一个背包。
物品i的重量是Wi，其价值为Vi，背包的容量为C。
应如何选择装入背包的物品，使得装入背包中物品的总价值最大? 与0-1背包问题类似，所不同的是在选择物品i装入背包时，可以选择物品i的一部分，而不一定要全部装入背包，但不可以重复装入。
2.[算法]：贪心法的基本思路：从问题的某一个初始解出发逐步逼近给定的目标，以尽可能快的地求得更好的解。
当达到某算法中的某一步不能再继续前进时，算法停止。
该算法存在问题：1）不能保证求得的最后解是最佳的；2）不能用来求最大或最小解问题；3）只能求满足某些约束条件的可行解的范围。
四、实现过程1、实验设计：1.用贪心法求解背包问题的关键是如何选定贪心策略，使得按照一定的顺序选择每个物品，并尽可能的装入背包，直至背包装满。
至少有三种看似合理的贪心策略：1）按物品价值v降序装包，因为这可以尽可能快的增加背包的总价值。
但是，虽然每一步选择获得了背包价值的极大增长，但背包容量却可能消耗太快，使得装入背包得物品个数减少，从而不能保证目标函数达到最大。
2）按物品重量w升序装包，因为这可以装入尽可能多的物品，从而增加背包总价值。
但是，虽然每一步选择使背包得容量消耗得慢了，但背包价值却没能保证迅速增长，从而不能保证目标函数达到最大。
背包问题实验报告(C语言实现、文件输入及文件输出)
背包问题实验题目：背包问题问题描述：假设有一个能装入总体积为T的背包和n件体积分别为w1, w2, … , wn的物品，能否从n件物品中挑选若干件恰好装满背包，即使w1+w2+…+ wn=T，要求找出所有满足上述条件的解。
例如：当T=10，各件物品的体积{1，8，4，3，5，2}时，可找到下列4组解：（1，4，3，2）（1，4，5）（8，2）（3，5，2）。
概要设计：采用栈数据结构，利用回溯法的设计思想来解决背包问题。
首先将物品排成一列，然后顺序选取物品装入背包，假设已选取了前i件物品之后背包还没有装满，则继续选取第i+1件物品，若该件物品“太大”不能装入，则弃之而继续选取下一件，直至背包装满为止。
但如果在剩余的物品中找不到合适的物品以填满背包，则说明“刚刚”装入背包的那件物品“不合适”，应将它取出“弃之一边”，继续再从“它之后”的物品中选取，如此重复，直至求得满足条件的解，或者无解。
ADT Stack {数据对象：D＝{ ai | ai∈ElemSet, i=1,2,...,n,n≥0 }数据关系：R1＝{ <ai-1, ai >| ai-1, ai∈D, i=2,...,n }约定an端为栈顶，a1端为栈底。
基本操作：InitStack(&S)操作结果：构造一个空栈S。
DestroyStack(&S)初始条件：栈S已存在。
操作结果：栈S被销毁。
ClearStack(&S)初始条件：栈S已存在。
操作结果：将S清为空栈。
StackEmpty(S)初始条件：栈S已存在。
操作结果：若栈S为空栈，则返回TRUE，否则FALSE。
StackLength(S)初始条件：栈S已存在。
操作结果：返回S的元素个数，即栈的长度。
GetTop(S, &e)初始条件：栈S已存在且非空。
操作结果：用e返回S的栈顶元素。
Push(&S, e)初始条件：栈S已存在。
操作结果：插入元素e为新的栈顶元素。
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、贪心法截图：七、实验分析。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
#include
#define N 100
typedefstruct 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
k = i;
for(j=i+1;j
{
temp[i]=d[i]; d[i]=d[k];
d[k]=temp[i];
}
}
}
float knapsack(){
int i;
float x[N],sum = 0; for(i=0;i
= 1;
sum += d[i].v;
xx,xx)： ");
c -= d[i].w; x[d[i].num] = c/d[i].w; } int i,j,k; }printf(" 请输入物品总数： "); for(i=0;i sum = knapsack(); printf("%.2f\n",sum);
}
if(i
sum += x[d[i].num] * d[i].v;
}
return sum;
int main(){
float sum;
scanf("%d",&n);
printf("\n 请输入背包容量： ");
scanf("%f",&c);
printf("\n
请输入各物品重量及价值(格
式：
for(i=0;i
}
for(i=0;i
b[i].w;
}
Sort();