c语言背包
① c语言：背包问题(数据结构)
详细程序代码如下:
用VC6.0编译.保存代码时,以.C为后缀名
下面是一组测试数据:
请输入背包能容纳的最大重量：20
请输入物品个数：10
请输入每一个物品的重量和价值：1,11,2,22, 3,33.....10,100
结果是正确的.
#include<stdio.h>
#include<conio.h>
#include<malloc.h>
#define NUMBER 20/*最大物品数量*/
#define TRUE 1
#define FALSE 0
struct Record/*本结构体用于保存每一次结果*/
{
int totalWeight;/*本次结果的总价值*/
int goods[NUMBER];/*本次结果对应的下标*/
struct Record *next;
};
struct Record *headLink;
struct Record result;
int stack[NUMBER];
int top;
int weight[NUMBER];/*保存物品重量的数组*/
int value[NUMBER];/*保存对应（下标相同）物品的价值*/
int knapproblen(int n,int maxweight,int weight[]);
void CreateHeadLink(void);
struct Record *MallocNode(void);
void InsertOneNode(struct Record *t);
void GetResult(void);
void ShowResult(void);
void main()
{
int n,i;
int maxWeight;/*背包能容纳的最大重量*/
printf("请输入背包能容纳的最大重量：\n");
scanf("%d",&maxWeight);
printf("请输入物品个数：\n");
scanf("%d",&n);
printf("请输入每一个物品的重量和价值：\n");
for(i=0;i<n;i++)
{
printf("请输入第%d个物品重量\n",i+1);
scanf("%d",&(weight[i]));
printf("请输入第%d个物品价值\n",i+1);
scanf("%d",&(value[i]));
}
if(knapproblen(n,maxWeight,weight)==TRUE)/*调用背包处理函数，如果成功就输出“答案”*/
{
GetResult();/*遍历链表，查找最佳的结果*/
ShowResult();/*显示结果*/
}
free(headLink);
getch();
}
/*调用背包处理函数*/
int knapproblen(int n,int maxweight,int weight[])
{
struct Record *p;
int i=1,j;
int tempTop=0;
top=0;/*先赋栈指针为0*/
CreateHeadLink();/*先建立链头*/
while((maxweight>0)&&(i<=n))/*当还可以装下物品，且物品没有用完时*/
{
if((maxweight-weight[i]==0)||(maxweight-weight[i]>0)&&(i<n))/*正好装完物品或还能容纳物品且物品没有用完时*/
{
stack[++top]=i;/*把对应物品的处标保存到栈中*/
p=MallocNode();/*每一次得到一个结果后，就将该结果保存到链表中*/
for(tempTop=top,j=0;tempTop>0;tempTop--,j++)
{
p->totalWeight+=value[stack[tempTop]];/*得到本次结果的总价值*/
p->goods[j]=stack[tempTop];/*得到本次结果对应的物品下标*/
}
InsertOneNode(p);/*加到链表中*/
maxweight=maxweight-weight[i];
}
if(maxweight==0)/*能装入包中*/
{
return TRUE;
}
else if((i==n)&&(top>0))/*继续测试*/
{
i=stack[top];
top=top-1;
maxweight=maxweight+weight[i];
}
i++;
}
return FALSE;
}
/************************************
函数功能：建立链表表头
************************************/
void CreateHeadLink(void)
{
struct Record *p;
p=(struct Record*)malloc(sizeof(struct Record));
headLink=p;
p->next=NULL;
}
/************************************
函数功能：申请一个新结点，并将其初始化
************************************/
struct Record *MallocNode(void)
{
struct Record *p;
int i;
p=(struct Record*)malloc(sizeof(struct Record));
if(p==NULL)
return NULL;
p->totalWeight=0;/*初始化总价值为0*/
for(i=0;i<NUMBER;i++)
p->goods[i]=-1;/*初始化下标为-1，即无效*/
p->next=NULL;
return p;
}
/************************************
函数功能：在链表的结尾处增加一个结点
************************************/
void InsertOneNode(struct Record *t)
{
struct Record *p;
p=headLink;
while(p->next)
{
p=p->next;
}
p->next=t;
}
/************************************
函数功能：遍历链表，找总价值最大的结点保存到
result中
************************************/
void GetResult(void)
{
struct Record *p;
int i;
result.totalWeight=headLink->next->totalWeight;/*先将第一个结点当作"最佳"结果*/
for(i=0;i<NUMBER;i++)
{
if(headLink->next->goods[i]==-1)
break;
result.goods[i]=headLink->next->goods[i];
}
p=headLink->next->next;
while(p)/*查找最佳结果*/
{
if(p->totalWeight>result.totalWeight)/*如果发现p点价值比当前结果还大，则将p又作为最佳结果*/
{
result.totalWeight=p->totalWeight;
for(i=0;i<NUMBER;i++)
result.goods[i]=-1;
for(i=0;i<NUMBER;i++)
{
if(p->goods[i]==-1)
break;
result.goods[i]=p->goods[i];
}
}
p=p->next;
}
}
/***************************
显示最佳结果
*******************************/
void ShowResult(void)
{
int i;
printf("最佳装载如下：\n");
for(i=0;i<NUMBER;i++)
{
if(result.goods[i]==-1)
break;
printf("weight[%d]=%d\tvalue[%d]=%d\t",result.goods[i],weight[result.goods[i]],result.goods[i],value[result.goods[i]]);
if((i+1)%2==0)
printf("\n");
}
printf("\n总价值是：\n%d",result.totalWeight);
}
② 背包问题，C语言编程
原始题目： 有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是
w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容
量，且价值总和最大。（取自网络）
问题简化： 1. 背包可容纳总重量为M
2. 有n个物品，每个重量为m[0]. m[1]. m[2] ......m[i] 对应每个物品的
价值为s[0]. S[1]. S[2]....s[i] (i<=n)
3. 放入第i个物品,比较m[i]和M的大小,不超过M则记录下当前价值s
4. 最终取得最大值s
实现方法：
定义三个浮点型一维数组float m[[n]和s[n]和y[n] 定义float M,float a,b定义int n,j, int i
请输入背包容量大小M：
please input the number of the things：
please input the value of the things：
把输入数据按顺序分别定义到数组中（若可以的话，把m[n]的数据由小到大排序，判断最小值m[0]和M的大小，若m[0]>M，输出error）
创建一个栈（这里的东西不太懂—-—）
将第一个数据压入栈底,定义i=0，把当前的m[i]赋值给a，s[i]赋值给b,把当前i存放进数组y[n]，以后在每次比较过程中，都把较大b值所对应的物品数存放进y[n]中
判断a<M（这里，若在4已经做过，则可省略，第一个数据一定小于M）
判断a+m[++i]<=M，为真，把第i（注意，此时i已经自增了，这个i是数组中的下标）个数据压入栈，赋值a=a+m[++i]，比较b和b+s[++i]的大小，赋值b=b+s[++i]（理论上，物品价值总该是为正的吧，若是这样的话，不用比较大小了，直接赋新值，直到跳出第一轮循环为止；另外有一种设想，若价值全为正，可以转而把问题这样简化：即给定容量大小和全为正的价值物品，现在想办法让背包放入物品的数量最多 就行了）；若为假，转10
如此进行一轮循环，直到出现10，此时b为一轮循环的最大值，return b,y[n]
当a+m[++i]>M，从栈中弹出m[i-2]，a=a-m[i-2],,当i原本就小于等于2的时候，则清除栈中数据，转12，判断a+m[i]<=M，为真，比较b和b-s[i-2]+s[i]，并把较大值赋给b，继续向下比较，这时候就不用压入栈中了,再定义一个j=1
判断a+m[i+j]<=M,为真，比较b和b-s[i-2]+s[i+j]大小，较大值赋给b，为假，从栈中弹出m[i-3]，当i原本就小于等于3的时候，则清除栈中数据，转12，判断a+m[i]<=M，为真，比较b和b-s[i-3]+s[i]（注意，这个b一直在被赋予最新值），如此进行第一轮循环，用for语句实现，因为下面还有嵌入
此时栈中没有数据，并且，已经把m[0]为栈底的循环计算完毕，现在开始计算m[1]为栈底的循环，在这一循环，忽略掉m[0]，所有可能情况已经在8-11计算过
依此往下，直到栈底被压入的是m[n]为止，计算完毕，输出b，并且输出数组y[n]
碰巧帮同学，也是这个问题，希望能帮助你。
③ C语言背包问题
《背包九讲》挺好的：http://wenku..com/link?url=QeRosxybnrqnCFvV-_
你这个属于多重背包问题。
可以把所有同类书都分开考虑成单独的书，就成了01背包
如果想要更快速看《背包九讲吧》
④ c语言背包问题
算法分析：
使用贪心策略求解此类问题时，首先要选出最优的度量标准。
可供选择的度量标准有三种：价值，容量，单位价值（v/w，价值/重量）。
显然，价值高的物品容量可能太大，容量大的物品价值也可能很低。最优的度量标准是单位价值。
背包问题算法思路：
1、将各个物品按照单位价值由高到低排序；
2、取价值最高者放入背包；
3、计算背包的剩余空间；
4、重复2-3步，直到背包剩余容量=0或者物品全部装入背包为止（对于0-1背包，终止条件为背包剩余容量无法装入任意一件物品或者物品全部装入背包）。
#include<stdio.h>
void package(int n,float c,float v[],float w[],float x[]);
void package0_1(int n,float c,float v[],float w[],float x[]);
int main(void)
{
int n = 3;
float c = 20;
float v[] = {24,15,25};
float w[] = {15,10,18};//已经按照单位价值降序排列
float *x;
x = (float*)malloc(sizeof(float)*n);
printf("******背包*******\n");
package(n,c,v,w,x);
printf("*******0-1背包******\n");
package0_1(n,c,v,w,x);
system("PAUSE");
}
/*
* 背包问题
* n:物品个数
* c：背包容量
* v[]:每个物品的价值
* w[]:每个物品的重量（这里已经按照单位价值降序排列 ）
* x[]:物品是否放入背包（0表示不放，1表示全部放入，0-1放入一部分）
*/
void package(int n,float c,float v[],float w[],float x[])
{
int i;
for(i=0;i<n;i++)
{
x[i] = 0;//初始状态，所有物品都没有被放入背包
}
for(i=0;i<n;i++)
{
if(w[i] > c)
{
break;
}
x[i] = 1;
c = c - w[i];
printf("放入第%d件物品，背包剩余容量%f.\n",(i+1),c);
}
if(i<=n)//还可以放入一个物品的一部分
{
x[i] = c/w[i];
printf("放入第%d件物品的%f部分.背包剩余容量为0.\n",(i+1),w[i]*x[i]);
}
}
/*
* 0-1背包问题
* n:物品个数
* c：背包容量
* v[]:每个物品的价值
* w[]:每个物品的重量（这里已经按照单位价值降序排列 ）
* x[]:物品是否放入背包（0表示不放，1表示全部放入）
*/
void package0_1(int n,float c,float v[],float w[],float x[])
{
int i;
for(i=0;i<n;i++)
{
x[i] = 0;//初始状态，所有物品都没有被放入背包
}
for(i=0;i<n;i++)
{
if(w[i] > c)
{
break;
}
x[i] = 1;
c = c - w[i];
printf("放入第%d件物品，背包剩余容量%f.\n",(i+1),c);
}
}
#include<stdio.h>
void package(int n,float c,float v[],float w[],float x[]);
void package0_1(int n,float c,float v[],float w[],float x[]);
int main(void)
{
int n = 3;
float c = 20;
float v[] = {24,15,25};
float w[] = {15,10,18};//已经按照单位价值降序排列
float *x;
x = (float*)malloc(sizeof(float)*n);
printf("******背包*******\n");
package(n,c,v,w,x);
printf("*******0-1背包******\n");
package0_1(n,c,v,w,x);
system("PAUSE");
}
/*
* 背包问题
* n:物品个数
* c：背包容量
* v[]:每个物品的价值
* w[]:每个物品的重量（这里已经按照单位价值降序排列 ）
* x[]:物品是否放入背包（0表示不放，1表示全部放入，0-1放入一部分）
*/
void package(int n,float c,float v[],float w[],float x[])
{
int i;
for(i=0;i<n;i++)
{
x[i] = 0;//初始状态，所有物品都没有被放入背包
}
for(i=0;i<n;i++)
{
if(w[i] > c)
{
break;
}
x[i] = 1;
c = c - w[i];
printf("放入第%d件物品，背包剩余容量%f.\n",(i+1),c);
}
if(i<=n)//还可以放入一个物品的一部分
{
x[i] = c/w[i];
printf("放入第%d件物品的%f部分.背包剩余容量为0.\n",(i+1),w[i]*x[i]);
}
}
/*
* 0-1背包问题
* n:物品个数
* c：背包容量
* v[]:每个物品的价值
* w[]:每个物品的重量（这里已经按照单位价值降序排列 ）
* x[]:物品是否放入背包（0表示不放，1表示全部放入）
*/
void package0_1(int n,float c,float v[],float w[],float x[])
{
int i;
for(i=0;i<n;i++)
{
x[i] = 0;//初始状态，所有物品都没有被放入背包
}
for(i=0;i<n;i++)
{
if(w[i] > c)
{
break;
}
x[i] = 1;
c = c - w[i];
printf("放入第%d件物品，背包剩余容量%f.\n",(i+1),c);
}
}
⑤ 完全背包问题，c语言编程
#include<stdio.h>
float V[1000],V1[1000];
int max(float a[],int n)
{
int s = 1;
float fmax = a[1];
for (int j=2;j<n;j++)
{
(a[j]>fmax)
{
fmax = a[j];
a[j] = 0;
s = j;
}
}
return s;
}
int KnapSack(int n,int w[],int v[],int C)
{
int Maxvalue = 0;
int X[1000],w0[1000],w1[1000];
memset(X,0,sizeof(X));
memset(w0,0,sizeof(w0));
memset(w1,0,sizeof(w0));
for (int j=1;j<n;j++)
{
V[i] = 1.0*v[i]/w[i];
V1[i] =V[i];
}
X[1] = max(V1,n);
int w0[1] = n/w[X];
int w1[1] = n%w[X];
int k = 1;
while (w1[k++]!=0)
{
X[K] = max(V1,n);
w0[k] = w1[k]/w[Y];
w1[k] = w1[k]%w[Y];
}
for (int m=1;m<k;m++)
{
Maxvalue+=w0[m]*w[X[K]]*v[X[k];
}
return Maxvalue;
}
int main(void)
{
int s;
int w[1000];
int v[1000];
int n,i;
int C;
scanf("%d %d", &C, &n);
for(i=0;i<n;i++)
scanf("%d %d",&w[i], &v[i]);
s=KnapSack(n,w,v,C);
printf("%d",s);
return 0;
}
⑥ 求大神给一份C语言01背包的代码，要每一行都有注释，谢谢！
这是一个背包问题，该算法已经是最简单的了，还有递归算法，我觉得更麻烦。对你的代码进行解释如下：
//背包问题：有m件物品和一个承重为t的背包。第i件物品的重量是w[i]，价值是v[i]。
//求解将哪些物品装入背包可使这些物品的重量总和不超过背包承重量t，且价值总和最大。
#include<stdio.h>
#include<conio.h>
#include<string.h>
intf[1010],w[1010],v[1010];//f记录不同承重量背包的总价值，w记录不同物品的重量，v记录不同物品的价值
intmax(intx,inty){//返回x,y的最大值
if(x>y)returnx;
returny;
}
intmain(){
intt,m,i,j;
memset(f,0,sizeof(f));//总价值初始化为0
scanf("%d%d",&t,&m);//输入背包承重量t、物品的数目m
for(i=1;i<=m;i++)
scanf("%d%d",&w[i],&v[i]);//输入m组物品的重量w[i]和价值v[i]
for(i=1;i<=m;i++){//尝试放置每一个物品
for(j=t;j>=w[i];j--){
f[j]=max(f[j-w[i]]+v[i],f[j]);
//在放入第i个物品前后，检验不同j承重量背包的总价值，如果放入第i个物品后比放入前的价值提高了，则修改j承重量背包的价值，否则不变
}
}
printf("%d",f[t]);//输出承重量为t的背包的总价值
printf(" ");
getch();
return0;
}
⑦ C语言 背包问题
这个答案是我在网上找到的，你自己看看吧
0/1背包经典问题：
需对容量为M的背包进行装载。从n 个物品中选取装入背包的物品，每件物品i 的重量为wi ，价值为pi 。对于可行的背包装载，背包中物品的总重量不能超过背包的容量，最佳装载是指所装入的物品价值最高，即n ?i=1pi xi 取得最大值。约束条件为n ?i =1wi xi≤c 和xi?[ 0 , 1 ] ( 1≤i≤n)。
我的程序：思想——动态规划法，先考虑没有物品要放的时候S0，再考虑只有一个要放物品a的各种情况S1，再综合考虑只有第一个a和第二个b物品要放时的情况S2，再综合考虑有三个待放物品abc的情况……
#include<stdio.h>
#include<iostream.h>
#define MAX 200
void main(void)
{
cout<<"******************************************************"<<endl
<<"******************* 0/1背包问题 ***************"<<endl
<<"******************* CopyRight: ***************"<<endl
<<"******************* Grace Air ***************"<<endl
<<"******************************************************"<<endl;
int n,M;
int num,t,q;
int temp;
int s[100];
int x[100];//决策集
int ww,pp,i,j,k,r,next;
int u;//记录附加结点
int P[100000],W[100000];//存放所有的可行序偶
P[0]=W[0]=0;//S0中的点(0，0)
int F[100];//记录si点的起点在P[]W[]数组中的位置
F[0]=0;F[1]=next=1;
int begin,end;begin=end=0;
int wi[100],pi[100],w[100],p[100];
cout<<"请输入下列背包初始信息:"<<endl;
cout<<endl<<"背包最大容量为：";
cin>>M;
cout<<endl<<"请输入下列物品初始信息:"<<endl;
cout<<endl<<"物品种类有几种？：";
cin>>n;
for(num=0;num<n;num++)
{
cout<<endl<<"第"<<num+1<<"种物品重量：";
cin>>wi[num];
cout<<" 价值：";
cin>>pi[num];
}
for(num=0;num<n;num++)
{
temp=wi[0];
q=0;
for(t=0;t<n;t++)
{
if(temp>wi[t])
{
temp=wi[t];
q=t;
}
}
s[q]=num+1;
w[num]=wi[q];
p[num]=pi[q];
wi[q]=MAX;
}
for(i=0;i<n;i++)
{
F[i+1]=end+1;
u=begin;//从头开始考虑序偶点
for(r=begin;r<end+1;r++)//生成sii图，s1中只考察结点0,
{
if(W[r]+w[i]<=M)
u=(W[r]+w[i])>(W[u]+w[i])?r:u;//s1的u=0,u是sii中能让i结点加上它把空间塞得最满的那个结点，即
//造成s12中x轴最向右靠近确定的M值的点的附加点
}//u号以前的点都是可以考虑加入的点
k=begin;//k是记录si-1图中已加入到si图中的点
for(j=begin;j<u+1;j++)//生成si图
{
ww=W[j]+w[i];
pp=P[j]+p[i];
while(k<=end&&W[k]<ww)//将si-1的点都加到si中
{
P[next]=P[k];
W[next]=W[k];
next++;k++;
}
if(k<=end&&W[k]==ww)
{
pp=pp>P[k]?pp:P[k];
k++;
}
if(pp>P[next-1])//sii中的点如果效益比以前的大，加进si
{
P[next]=pp;
W[next]=ww;
next++;
}
while(k<=end&&P[k]<=P[next-1])
k++;
}
begin=end+1;
end=next-1;
}
//回溯
int PX,WX,PY,WY;
PX=P[end];WX=W[end];
for(i=n;i>0;i--)
{
PY=P[F[i]-1];WY=W[F[i]-1];
if(PX>PY)
{
x[i]=1;
PX=PX-p[i-1];WX=PY-w[i-1];
}
else x[i]=0;
}
cout<<endl<<"最优决策为：";
for(i=0;i<n;i++)
cout<<x[s[i]]<<" ";
cout<<endl<<"最优效益为:"<<P[end]<<endl<<"重量："<<W[end]<<endl;
}
⑧ 背包问题(C语言)
我一下别人的递归算法，假如你有时间限时的话，那我就用动态规划帮你重新code一个
#include <stdio.h>
#define N 100 //物品总种数不是常量，没法根据它来决定数组的长度，只有先定义个长度了
int n;//物品总种数
double limitW;//限制的总重量
double totV;//全部物品的总价值
double maxv;//解的总价值
int option[N];//解的选择
int cop[N];//当前解的选择
struct {//物品结构
double weight;
double value;
}a[N];
//参数为物品i,当前选择已经达到的重量和tw,本方案可能达到的总价值
void find(int i,double tw,double tv)
{
int k;
//物品i包含在当前方案的可能性
if(tw+a[i].weight <= limitW){
cop[i]=1;
if(i<n-1)find(i+1,tw+a[i].weight,tv);
else{
for(k=0;k<n;++k)
option[k]=cop[k];
maxv=tv;
}
}
cop[i]=0;
//物品i不包含在当前方案的可能性
if(tv-a[i].value>maxv){
if(i<n-1)find(i+1,tw,tv-a[i].value);
else{
for(k=0;k<n;++k)
option[k]=cop[k];
maxv=tv-a[i].value;
}
}
}
void main()
{
int k;
double w,v;
printf("输入物品种数:");
scanf("%d",&n);
printf("输入各物品的重量和价值:");
for(totV=0.0,k=0;k<n;++k){
scanf("%lf %lf",&w,&v);
a[k].weight = w;a[k].value = v;
totV += v;
}
printf("输入限制重量:");
scanf("%lf",&limitW);
maxv=0.0;
for(k=0;k<n;++k)cop[k]=0;
find(0,0.0,totV);
for(k=0;k<n;++k)
if(option[k])printf("%4d",k+1);
printf("总价值为: %2f",maxv);
}
⑨ 用C语言实现背包问题求解。
#include<stdio.h>
#define OK 1
#define ERROR 0
#define SElemtype int
#define STACKSIZE 100
typedef struct{
SElemtype data[STACKSIZE];
int top;
} SqStack;SElemtype Initstack(SqStack &s)//初始化栈。
{
s.top=0;
return OK;
}SElemtype Push(SqStack &s,SElemtype e)//入栈。
{
s.data[s.top++]=e;
return OK;
} void main()
{
int i,n,totalvol,w[STACKSIZE],sum=0,j=0;
SqStack s;
Initstack(s);
printf("请输入背包能装入的总体积：");
scanf("%d",&totalvol);
printf("请输入物品件数：");
scanf("%d",&n);
printf("请输入每件物品的体积：");
for(i=0;i<n;i++)
scanf("%d",&w[i]);
while(s.top!=-1)
{ if(sum+w[j]<=totalvol)
{
Push(s,j);
sum+=w[j];
} if(sum==totalvol) //找到一组，退栈顶，找下一组。
{
for(i=0;i<s.top;i++)
printf("%d ",w[s.data[i]]);
printf("\n"); s.top--;
sum-=w[s.data[s.top]];
j=s.data[s.top]+1;
} else
j++;
while(j==n) //遍历后仍未找到，则退栈。
{
s.top--;
sum-=w[s.data[s.top]];
j=s.data[s.top]+1;
}
}}
⑩ c语言背包问题，求高手解答
对01背包求解，方法有回溯法、分支限界法、动态规划法等。给你一个较容易理解的解法：穷举搜索。问题求解的结果实际上是一个01序列，0表示该物品未装入背包，1表示装入背包。以本题为例，设求解结果为0111011，表示第0个和第4个未装入，其他均装入。关键就是如何找到这个01序列。设物品数量为n，则解空间为2^n，所以穷举搜索的时间效率为O(2^n)。
#include <stdio.h>
#define N 7
int weight[N]={35, 30, 6, 50, 40 10, 25}, cost[N]={10, 40, 30, 50, 35, 40, 30};
char name[] = "ABCDEFG";
int max = 0, Max[N]; /*max用于存放最大价值，Max用于存放最优解向量*/
int v[N]; /*v：求解时用于存放求解过程向量*/
template <class T>
void Swap(T &a, T &b)
{
T tmp = a;
a = b, b = tmp;
}
void Knapsack(int step, int bag, int value1, int value2, int n)
/*step表示第step步的选择（即第step个物品的选择），bag为背包剩余容量，value1表示包中现有物品总价值，value2表示剩余物品总价值，n为物品总数量*/
{
int i;
if((step >= n) || (weight[step] > bag) || (value1 + value2 <= max)) /*如果所有物品都选择完毕或剩余的物品都放不进或者包中物品总价值与剩余物品总价值之和小于等于目前的已知解，则找到一个解(但不一定是最终解或更优解)*/
{
for(i = step; i < n; i++) v[i] = 0; /*剩余的物品都不放入*/
if(value1 > max) /*如果本次求得的解比以往的解更优，则将本次解作为更优解*/
{
max = value1;
for(i = 0; i < n; i++) Max[i] = v[i]; /*将更优解保存到Max向量中*/
}
return;
}
v[step] = 0, Knapsack(step + 1, bag, value1, value2 - cost[step], n); /*不将第step个物品放入背包，第step个物品的价值被放弃，进行下一步的选择*/
v[step] = 1, Knapsack(step + 1, bag - weight[step], value1 + cost[step], value2 - cost[step], n); /*将第step个物品放入背包，进行下一步的选择*/
}
void main( )
{
/*输入数据：背包容量、物品数量、重量、价值 代码略*/
int bag = 150, i, j, min, totalcost;
/*按物品重量从小到大的顺序对物品排序，排序时cost向量中的相对顺序也要作相应移动*/
for(i = 0; i < N - 1; i++) {
for(min = i, j = i + 1; j < N; j++)
if(weight[j] < weight[min]) min = j;
if(i != min) {
Swap(weight[i], weight[min]);
Swap(cost[i], cost[min]);
Swap(name[i], name[min]);
}
}
for(totalcost = 0, i = 0; i < N; i++) totalcost += cost[i]; /*求总价值*/
Knapsack(0, bag, 0, totalcost, N); /*bag为空背包容量, totalcost为物品总价值, N为物品数量*/
/*以下输出解*/
printf("最大价值为: %d。\n装入背包的物品依次为：\n", max);
for(i = 0; i < N; i++)
if(Max[i]) printf("%c\t", name[i]);
printf("\n");
}
我的回答你满意吗？如果满意，就请点赞哦，或者你也可以继续追问。