0-1背包问题的多种算法设计与分析
一、实验内容和要求：
0-1背包问题是一例典型的组合优化的NP完全问题。问题可以描述为：给定一组共n个物品，每种物品都有自己的重量wi, i=1~n和价值vi, i=1~n，在限定的总重量（背包的容量C）内，如何选择才能使得选择物品的总价值之和最高。选择最优的物品子集放置于给定背包中，最优子集对应n元解向量(x1,…xn), xi∈{0或1}，因此命名为0-1背包问题。
0-1背包问题是许多问题的原型，但它又是一个NP完全问题。此实验主要研究和实现n(0<=n<=200)和C(C<=2000, C为整数)都较大的情形，随机产生n个物品的重量向量wi(1<=wi<=100, wi为整数)和价值向量vi (1<=vi<=100, vi为整数)。
0-1背包问题可以用许多方法来求解，有些算法可以得到问题的精确最优解，有些仅能获得一个近似最优解。本综合设计性实验要求用3种以上的方法求解0-1背包问题，获得精确最优解或近似最优解皆可，并对所采用的多种算法从运行时间、寻找是否为最优解、能够求解的问题规模等方面进行对比和分析。本课程讲述的算法思想都可以用来求解此问题，甚至本课程未涉及的许多算法也非常适合于求解此问题，学生可以先尝试先用本课程介绍的算法来实现和分析，学有余力或兴趣驱动下可以寻找一些智能算法的资料来试一试。涉及的方法可以有：蛮力求解、递归求解、动态规划求解、贪心求解、回溯法求解、广度优先的分支限界法求解，优先队列的启发式分支限界法、遗传算法、模拟退火算法、蚁群算法、粒子群算法等。
为方便调试，采用文件输入，标准输出（或文件输出也可）的形式。数据输入的格式如下：每组测试数据包含n+1行，第1行为C和n，表示背包容量为C且有n个物品，接下来n行为这n个物品的重量wi和价值vi。背包容量和物品重量都为整数。n, C , wi, vi范围如上所述。
输出两行。第一行为所选物品的最大价值之和，第二行为装入背包的物品所对应的n元最优解向量(x1,…xn), xi∈{0或1}。
二、多种算法详细设计
1.贪心算法
输入物品价值和重量。分别用数组v[o..n]和w[0..n]来记录。根据物品价值v[i]/w[i]由高到低对v[o..n]和w[0..n]进行排序。然后把物品从1到n依次加入背包,直到装不下为止。设c为背包容量，每次装一个物品，则c-=w[i],当前价值为value+=v[i],当c<=0时，停止加入物品，此时的value即为最优值。
对于背包问题，贪心选择最终可得到最优解，但对于0-1背包问题，贪心选择无法保证最终能将背包装满，部分闲置的背包空间使单位背包空间的价值降低了。
2.递归求解
1）0-1背包最优问题具有最优子结构性质。设（y1,y2,...,yn)是所给0-1背包的
一个最优解，则（y2,y3,...,yn)是除了y1外的最优解。
2）设所给0-1背包问题的子问题的最优值为m（i，j）,即m（i，j）是背包容量为j，可选物品为i，i+1，...，n时0-1背包问题的最优值。由0-1背包的问题的最优子结构性质，可以建立计算m（i，j）的递归式如下：
m（i，j）=max{m（i+1，j），m（i+1，j-wi）+vi} j>=wi
=m（i+1，j） 0<=j<wi
m（i，j）=vn j>=wn
=0 0<=j<wn
用二维数组m[i][j]存储m（i，j）的值。根据递归式算出m[i][j]的值。则m[1][c]是给出所要求的0-1背包问题的最优值。相应的最优解可由算法Traceback计算如下。如果m[1][c]=m[2][c],则x1=0,否则x1=1.当x1=0时，由m[2][c]继续构造最优解。当x1=1时，由m[2][c]继续构造最优解。当x1=1时，由m[2][c-w1]继续构造最优解。依次类推，可构造出相应的最优解（x1，x2，...，xn）。
void Traceback(int **m,int n,int *w,int c,int *x)
{
int i;
if(m[1][c]==m[2][c])
x[1]=0;
else x[1]=1;
for(i=1;i<=n-2;i++)
{
if(x[i]==1)
c-=w[i];
if(m[i+1][c]==m[i+2][c])
x[i+1]=0;
else x[i+1]=1;
}
if(m[n][c]!=0)
x[n]=1;
}
3.动态规划
基于递归式的讨论，用二维数组m[][]来存储m（i，j）的相应值，可设计解0-1背包问题的动态规划算法Knapsack如下：
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(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(j=0;j<=jMax;j++) m[i][j]=m[i+1][j];
for(j=w[i];j<=c;j++) m[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)
{
fpr(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;
}
4.回溯法求解
0-1背包问题是子集选取问题。一般情况下，0-1背包问题是NP难的。0-1背包问题的解空间可用子集树表示。在搜索解空间树时，只要其左儿子结点是一个可行结点，搜索就进入其左子树。当右子树中有可能包含最优解时才进入右子树搜索。否则将右子树剪去。设r是当前剩余物品价值总和；cp是当前价值；bestp是当前最优价值。计算右子树上界的方法是将剩余物品依其单位重量价值排序，然后依次装入物品，直至装不下去时，再装入该物品的一部分而装满背包。由此得到的价值是右子树中解的上界。 为了计算上界，可先将物品依其单位重量价值从小到大排序，此后只要按顺序考察各物品即可。
将物品依其单位价值排序的算法如下：
class Object{
friend int Knapsack(int*,int*,int,int,int*);
friend void Sort(Object*,int);
public:
int operator<=(Object a)const
{return (d>=a.d);}
private:
int ID;
float d;//单位重量价值
};
void Sort(Object *Q,int len)
{
for(int i=0;i<len;i++)
for(int j=0;j<len;j++)
if(Q[i]<=Q[j])
{
Object temp=Q[i];
Q[i]=Q[j];
Q[j]=temp;
}
}
在实现时，由Bound计算当前结点处的上界。类Knap的数据成员记录解空间树中的结点信息，以减少参数传递及递归调用所需的栈空间。在解空间树的当前扩展结点处，仅当要进入右子树时才计算上界与其父节点的上界Bound，以判断是否可将右子树剪去。进入左子树时不需要计算上界，因为其上界与其父结点的上界相同。
在计算最优值的时候也要在另设一个数组bestx[1..n]来记录最优解，在Backtrack算法中回溯得到bestx，当得到第一个最优值，若后面回溯到叶结点时值不大于当前最优值，则最优解bestx不改变。Backtrack中得到最优值和最优解的算法如下： template<class Typew,class Typep>
void Knap<Typew,Typep>::Backtrack(int i)
{
int flag;
if(i>n){//到达叶节点
flag=bestp<cp;
if(flag)
{ bestp=cp;
for(i=1;i<=n;i++)
bestx[ID[i]]=x[ID[i]];
}
return;}
if(cw+w[i]<=c){//进入左子树
cw+=w[i];
cp+=p[i];
x[ID[i]]=1;
Backtrack(i+1);
cw-=w[i];
cp-=p[i];
}
if(Bound(i+1)>bestp)//进入右子树
{
x[ID[i]]=0;
Backtrack(i+1);}
}
5.分支界限法
在解0-1背包问题的优先队列式分支限界法中，活结点优先队列中结点元素N的优先级由该结点的上界函数Bound计算出的值uprofit给出。上界函数与回溯法一样。子集树中以结点N为根的子树中任一结点的价值不超过N.profit。可用一个最大堆来实现活结点优先队列。堆中元素类型为HeapNode。其私有成员有uprofit，profit，weight和level。对于任意活结点N，N.weight是结点N所相应的重量；N.profit是N所相应的价值；N.uprofit是结点N的价值上界，最大堆以这个值作为优先级。子集空间树中结点类型为bbnode。
类Knap的成员bestx用来记录最优解。Bestx[i]=1当且仅当最优解含有物品i。
算法MaxKnapsack实施对子集树的优先队列式分支限界搜索。
算法中E是当前扩展结点；cw是该结点所相应的重量；cp是相应的价值；up是价值上界。算法的while循环不断扩展结点，直到子集树的叶结点成为扩展结点时为止。此时优先队列中所有结点的价值上界均不超过该结点的价值。因此该叶结点相应的解为问题的最优解。
在while循环内部，算法首先检查当前扩展结点的左儿子结点的可行性。如果该左儿子结点是可行结点，则将它加入到子集树和活结点优先队列中。当前扩展结点的右儿子结点一定是可行结点，仅当右儿子结点满足上界约束时才将它加入子集树和活结点优先队列。
建立最大堆MaxHeap，并对HeapNode类中做相应修改，目的是为了使最大堆能根据N.uprofit值作相应调整。修改如下：
template<class Typew,class Typep>
class HeapNode{
friend Knap<Typew,Typep>;
public:
int operator < (HeapNode a)const {return uprofit<a.uprofit;}
int operator > (HeapNode a)const {return uprofit>a.uprofit;}
private:
Typep uprofit,//结点的价值上界
profit;//结点所相应的价值
Typew weight;//结点所相应的重量
int level;//活结点在子集树中所处的层序号
bbnode *ptr;//指向活结点在子集树中相应结点的指针
};
三、多种算法调试和测试
1.贪心算法
对于背包问题，贪心选择最终可得到最优解，但对于0-1背包问题，贪心选择无法保证最终能将背包装满，部分闲置的背包空间使单位背包空间的价值降低了。 测试中数据基本与最优值相似，有的则相差较大。贪心算法得出的结不一定是最优解。
2.递归求解
在编写递归的算法，最关键的就是怎样用二维数组来表示相应最优解的值，编写的时候需要注意传值。思路清晰，把数学的递归式用代码函数表示出来。
对于递归求解，算法简单，但消耗时间太长。在数据较少的情况下，可以很快得到正确结果，当数据达到35个数据的时候，需要较长时间，当数据达到40个以上的时候，由于时间太长则等待不出结果。可见递归的效率很低。
针对递归算法效率较低，可采用动态规划进行改进。
3.动态规划
采用动态规划算法，效率较高。用所提供的数据测试，均能很快得出正确结果。 在编写动态规划算法时，没有太大问题，只需要编写求出最大值和最小值的函数。还有回溯求最优解的算法。
4.回溯法求解
在编写该算法时首先遇到的第一个问题是要运用C++的一些语法，这对于只懂C的同学确实存在一下障碍。好在我们的小组成员有些人之前学过，所以在这方面问题不大，再加上不懂时通过网上查阅资料和相关书籍，问题很快就得到解决。
另外，就是在Backtrack算法中求出最优值和最优解，每次当剩余的价值大于bestp，则进入右子树进行搜索。当到达叶结点时即得到一个最优值，把值赋给bestp，得到新的最优值。同时需记录最优解，此时把记录路径的数组x[1..n]的值赋给bestx[1..n]。
在记录最优解时需要注意一个问题。因为回溯的顺序是按照物品单位价值从高到低的顺序进行的，而输出的最优解则需要按照原顺序输出。所以在回溯中记录路径时，需注意记录的是原来次序下的路径，而不是排序后的路径。在这里我们在排序之前已经定义好一个类Q。类中的数据成员ID用来记录物品原来的位置。则排序后，物品原来的位置记录仍能被找到。则搜索到某个结点时，则x[ID[i]]=1,否则x[ID[i]]=0.
5.分支界限法
分支限界法的与回溯法不同的是前者是深度优先搜索，后者是广度优先搜索。分支限界法的效率会高些，但是需要建立一个最大堆作为优先队列。
定义一个类MaxHeap来实现优先队列，定义如下：
template<class T>
class MaxHeap
{
public:
MaxHeap(T a[], int size,int maxsize=50);
MaxHeap(int maxsize=50);
virtual ~MaxHeap();
void Initialize(T arrays[],int size,int array_size);//用数组对堆重新进行初始化
MaxHeap<T>& Insert( T value);
MaxHeap<T>& DeleteMax(T& value );
bool IsEmpty(){return CurrentSize==0?true:false;};
int Size(){return CurrentSize;}
void Init(T a[]);
private:
void ModifyUp(int start);
void ModifyDown(int start,int end);
private:
T *Data;
int MaxSize;
int CurrentSize;
};
调试后小结：
从编程到调试到可以运行中总会遇到各种各样的问题。在本次综合实验中我们一会颇深，在试验中我们学到了新知识，一些C++的语法，一些调试的技巧，以及根据纠错提示改错。同时也巩固了一些旧的知识，如文件的读写操作，输入输出。先把总结如下：
(1)C++的语法，定于各种类，增加了程序可读性，是程序比较容易理解。同时在类中定义友元类或者友元函数，使类之间的某些操作不受限制，方便程序员的编写，完善功能。另外，类中的函数可在类中先申明，然后类在外定义，也是非常方便的。还有运算符的重载，以及类模板，函数模板的使用都增加了程序的可读性和易编写性。
(2)说来有点惭愧，在这次综合实验中，才真正学会VC的单步调试和断点，这给我们编写程序带来极大便利。另外通过查看每歩程序的输出，也可以方便的找出错误。
(3)这里是一些纠错提示：
1.C程序编译时出现warnning no newline at end of file。
解决办法：在文件最后添加一个空白行。
2.LINK : fatal error LNK1168: cannot open Debug/Test.exe for writing 解决办法：
打开任务管理器，将test.exe进程杀掉，然后重新编译链接
(4)数据的格式读入，由于数据很多，所以采用文件输入比较方便。 FILE *fp;
fp=fopen("D:\\bag.txt","r");//以读的方式打开文件 if(!fp) {
printf("file cannot be opened"); exit(1); }
fscanf(fp,"%Ld%Ld",&c,&n); 数据的文件格式输出 FILE *ptr;
ptr=fopen("D:\\result.txt", "w");//以写的方式打开文件 fprintf(ptr,"%d\n",value); for(i=1;i<=n;i++)
fprintf(ptr,"%d %d\n",i,x[i]);
最后还要关闭文件。 fclose(fp); fclose(ptr);
四、多种算法对比
五、附录多种算法实现清单：带注释和功能模块说明的源程序清单：
1.贪心算法
#include<iostream> using namespace std;
void sort2(int n,int *v,int *w,int*& sort) {
int i,j,temp;
}
int Greedy(int n,int *w,int *v,int*& x,int c,int* sort) {
int i,value=0;
for(i=n;i>=1;i--)
{
c-=w[sort[i]];
if(c>=0)
{x[sort[i]]=1;value+=v[sort[i]];}
else break;
}
return value;
}
int main()
{
int n,c,i,value;
FILE *fp;
FILE *ptr;
int *x,*w,*v,*sort;
fp=fopen("D:\\bag.txt","r");//以读的方式打开文件
fscanf(fp,"%Ld%Ld",&c,&n); if(!fp) { } printf("file cannot be opened"); exit(1); for(i=2;i<=n;i++) { } for(j=1;j<=i;j++) if(v[sort[i]]/w[i]<v[sort[j]]/w[j]) { } temp=sort[i];sort[i]=sort[j];sort[j]=temp;
x=new int[n+1];
w=new int[n+1];
v=new int[n+1];
sort=new int[n+1];
for(i=1;i<=n;i++)
fscanf(fp,"%Ld%Ld",&w[i],&v[i]);
sort2(n,v,w,sort);//从小到大
value=Greedy(n,w,v,x,c,sort);//调用函数
ptr=fopen("D:\\result.txt", "w");//以写的方式打开文件 fprintf(ptr,"%d\n",value);
for(i=1;i<=n;i++)
fprintf(ptr,"%d %d\n",i,x[i]);
fclose(fp);
fclose(ptr);
return 0;
} for(i=1;i<=n;i++) {sort[i]=i; x[i]=0;}
2.递归求解
#include<iostream>
using namespace std;
int ma(int i,int j,int n,int **&m,int *w,int *v) {
int a,b,value;
if(i==n)
{
}
if(i<n)
{if(j>=w[i])
{
m[i+1][j]=ma(i+1,j,n,m,w,v);
a=m[i+1][j]; if(j>=w[n]) value=v[n]; else value=0; return value;
m[i+1][j-w[i]]=ma(i+1,j-w[i],n,m,w,v);//递归的调用 b=m[i+1][j-w[i]]+v[i];
if(a>b)
value=a;
else value=b;
return value;
}
else
{m[i+1][j]=ma(i+1,j,n,m,w,v);//递归的调用 value=m[i+1][j];
return value;
}
}
else
return 0;
}
void Traceback(int **m,int n,int *w,int c,int *x) {
int i; if(m[1][c]==m[2][c]) x[1]=0; else x[1]=1; for(i=1;i<=n-2;i++) { } if(x[i]==1) c-=w[i]; if(m[i+1][c]==m[i+2][c]) x[i+1]=0; else x[i+1]=1;
if(m[n][c]!=0)
x[n]=1;
}
int main()
{
int n,c,i;
FILE *fp;
FILE *ptr;
int *x,*w,*v,**m;
fp=fopen("D:\\bag.txt","r");//以读的方式打开文件 if(!fp) {
} printf("file cannot be opened"); exit(1);
fscanf(fp,"%Ld%Ld",&c,&n);
x=new int[n+1];
w=new int[n+1];
v=new int[n+1];
m=new int*[n+1];
for(i=1;i<=n;i++)
{
}
for(i=1;i<=c;i++)
{
}
m[1][c]=ma(1,c,n,m,w,v);//调用函数
Traceback(m,n,w,c,x);//调用函数
ptr=fopen("D:\\result.txt", "w");//以写的方式打开文件 fprintf(ptr,"%d\n",m[1][c]);
for(i=1;i<=n;i++)
fprintf(ptr,"%d %d\n",i,x[i]);
fclose(fp);//关闭文件
fclose(ptr);//关闭文件
return 0;
} if(i>=w[n]) m[n][i]=v[n]; else m[n][i]=0; m[i]=new int[c+1]; x[i]=0; fscanf(fp,"%Ld%Ld",&w[i],&v[i]);
3.动态规划
#include<iostream>
using namespace std;
int min(int a,int b)
{
}
if(a<b) return a; else return b;
int max(int a,int b)
{
}
template<class Type>
void Knapsack(Type* v,int* w,int c,int n,Type** m) {
}
template <class Type>
void Traceback(Type **m,int *w,int c,int n,int *x) {
}
void Traceback(int **m,int n,int *w,int c,int *x) {
int i; if(m[1][c]==m[2][c]) x[1]=0; else x[1]=1; for(i=1;i<=n-2;i++) { fpr(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; int jMax=min(w[n]-1,c); for(int j=0;j<=jMax;j++) m[n][j]=0; for(j=w[n];j<=c;j++) m[n][j]=v[n]; for(int i=n-1;i>1;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]); jMax=min(w[i]-1,c); for(j=0;j<=jMax;j++) m[i][j]=m[i+1][j]; for(j=w[i];j<=c;j++) m[i][j]=max(m[i+1][j],m[i+1][j-w[i]]+v[i]); if(a>b) return a; else return b;
} if(x[i]==1) c-=w[i]; if(m[i+1][c]==m[i+2][c]) x[i+1]=0; else x[i+1]=1;
if(m[n][c]!=0)
x[n]=1;
}
int main()
{
int n,c,i;
FILE *fp;
FILE *ptr;
int *x,*w,*v,**m;
x=new int[n+1];
w=new int[n+1];
v=new int[n+1];
m=new int*[n+1];
for(i=1;i<=n;i++)
{
}
Knapsack(v,w,c,n,m);
Traceback(m,n,w,c,x);
ptr=fopen("D:\\result.txt", "w"); fprintf(ptr,"%d\n",m[1][c]); for(i=1;i<=n;i++)
fprintf(ptr,"%d %d\n",i,x[i]); m[i]=new int[c+1]; x[i]=0; fscanf(fp,"%Ld%Ld",&w[i],&v[i]); fp=fopen("D:\\bag.txt","r");//以只读的方式打开文件 if(!fp) { } printf("file cannot be opened"); exit(1); fscanf(fp,"%Ld%Ld",&c,&n);
fclose(fp);
fclose(ptr);//关闭两个文件
return 0;
}
4.回溯法求解
#include<iostream>
using namespace std;
template<class Typew,class Typep> class Knap{
};
/*
template<class Typew,class Typep>
Typep Knap<Typew,Typep>::Bound(int i) {//计算结点所相应价值的上界
int j;
Typep pp=cp;Typew ww=cw;
for(j=i;j<=n;j++)
{
}
ww-=w[j];
pp+=p[j]/(c-ww); ww+=w[j]; if(ww<=c) pp+=p[j]; else break; friend Typep Knapsack(Typep*,Typew*,Typew,int,int*); private: Typep Bound(int i); void Backtrack(int i); Typew c;//背包容量 int n;//物品总数 Typew *w;//物品重量数组 Typep *p;//物品价值数组 int *x; int *ID; Typew cw;//当前装包重量 Typep cp;//当前装包价值 Typep bestp;//当前最优价值 int *bestx;
return pp;
}
*/
template<class Typew,class Typep>
Typep Knap<Typew,Typep>::Bound(int i) {//计算结点所相应价值的上界
}
template<class Typew,class Typep>
void Knap<Typew,Typep>::Backtrack(int i) {
flag=bestp<cp; if(flag) { } return;} cw+=w[i]; cp+=p[i]; x[ID[i]]=1; Backtrack(i+1); cw-=w[i]; cp-=p[i]; } bestp=cp; bestx[ID[i]]=x[ID[i]]; for(i=1;i<=n;i++) int flag; if(i>n){//到达叶节点 Typew cleft=c-cw; Typep b=cp;//以物品单位重量价值递减序装入物品 while(i<=n&&w[i]<=cleft){ }//装填剩余容量装满背包 if(i<=n)b+=p[i]*cleft/w[i]; return b; cleft-=w[i]; b+=p[i]; i++; if(cw+w[i]<=c){//进入左子树 if(Bound(i+1)>bestp)//进入右子树
}
{ x[ID[i]]=0; Backtrack(i+1);}
class Object{
};
void Sort(Object *Q,int len) {
for(int i=0;i<len;i++)
for(int j=0;j<len;j++) if(Q[i]<=Q[j])
{
Object temp=Q[i]; Q[i]=Q[j]; Q[j]=temp; }
}
/*void Sort(Object* Q,int n) {
int i,j,temp;
for(i=2;i<=n;i++) { } for(j=1;j<=i;j++) if(Q[i-1].d<Q[j-1].d) { } temp=Q[i-1].ID;Q[i-1].ID=Q[j-1].ID;Q[j-1].ID=temp; friend int Knapsack(int*,int*,int,int,int*); friend void Sort(Object*,int); int operator<=(Object a)const {return (d>=a.d);} int ID; float d;//单位重量价值 public: private:
}
*/
template<class Typew,class Typep>
Typep Knapsack(Typep p[],Typew w[], Typew c,int n,int *x) {//返回最大价值，bestx返回最优解
Typew W=0;//装包物品重量
Typep P=0;//装包物品价值 Object *Q=new Object[n]; for(int i=1;i<=n;i++){ } if(W<=c) return P;//所有物品装包 Sort(Q,n); //创建类Knap的数据成员 Knap<Typew,Typep>K; K.p=new Typep[n+1]; K.w=new Typew[n+1]; K.ID=new int[n+1]; K.x=new int[n+1]; for(i=1;i<=n;i++){ } K.cp=0; K.cw=0; K.c=c; K.n=n; K.bestp=0; K.bestx=x; K.Backtrack(1); delete[]Q; delete[]K.w; delete[]K.p; return K.bestp; K.p[i]=p[Q[i-1].ID]; K.w[i]=w[Q[i-1].ID]; K.ID[i]=Q[i-1].ID; K.x[i]=0; Q[i-1].ID=i; Q[i-1].d=1.0*p[i]/w[i]; P+=p[i]; W+=w[i]; //定义依单位重量价值排序的物品数组 //单位重量价值数组 //依单位重量价值排序 //回溯搜索
}
int main()
{
int n,c,i,value;
FILE *fp;
FILE *ptr;
int *x,*w,*v;
fscanf(fp,"%Ld%Ld",&c,&n);
x=new int[n+1];
w=new int[n+1];
v=new int[n+1];
for(i=1;i<=n;i++)
{
}
value=Knapsack(v,w,c,n,x);
//cout<<value<<endl;
int va=0;
for(i=1;i<=n;i++)
if(x[i])
va+=v[i];
cout<<va<<endl;
ptr=fopen("D:\\result.txt", "w"); fprintf(ptr,"%d\n",value); x[i]=0; fscanf(fp,"%Ld%Ld",&w[i],&v[i]); { } printf("file cannot be opened"); exit(1); fp=fopen("D:\\bag.txt","r"); if(!fp)
for(i=1;i<=n;i++)
fprintf(ptr,"%d %d\n",i,x[i]);
fclose(fp);
fclose(ptr);
return 0;
}
5.分支界限法
#include<iostream>
using namespace std;
#include<algorithm>
#ifndef MAXHEAP_H
#define MAXHEAP_H
template<class T>
class MaxHeap
{
public:
MaxHeap(T a[], int size,int maxsize=50);
MaxHeap(int maxsize=50);
virtual ~MaxHeap();
void Initialize(T arrays[],int size,int array_size);//用数组对堆重新进行初始化
MaxHeap<T>& Insert( T value);
MaxHeap<T>& DeleteMax(T& value );
bool IsEmpty(){return CurrentSize==0?true:false;};
int Size(){return CurrentSize;}
void Init(T a[]);
private:
void ModifyUp(int start);
void ModifyDown(int start,int end);
private:
T *Data;
int MaxSize;
int CurrentSize;
};
template<class T>
MaxHeap<T>::MaxHeap(T a[], int size,int maxsize)
{
Data=a;
CurrentSize=size;
MaxSize=maxsize;
for( int i=CurrentSize/2;i>=1;i--)
{
ModifyDown(i,CurrentSize);
}
}
//----------------------------------------------------------------------- template<class T>
void MaxHeap<T>::Initialize(T arrays[],int size,int array_size)
{
if(Data)
delete[] Data;
Data=arrays;
CurrentSize=size;
MaxSize=array_size;
for(int i=CurrentSize/2;i>=1;i--)
{
ModifyDown(i,CurrentSize);
}
}
//------------------------------------------------------------------------- template<class T>
MaxHeap<T>::MaxHeap(int maxsize)
{
//0号单元不用舍弃，数据从一号单元填入
MaxSize=maxsize;
Data=new T[MaxSize+1];
CurrentSize=0;
}
//-------------------------------------------------------------------------
template<class T>
MaxHeap<T>::~MaxHeap()
{
delete[] Data;
}
//------------------------------------------------------------------------- template<class T>
MaxHeap<T>& MaxHeap<T>::Insert(T value)
{
if(CurrentSize==MaxSize)
{
cout<<"错误:堆空间已满."<<endl;
throw exception("堆空间已满");
}
Data[++CurrentSize]=value;
ModifyUp(CurrentSize);//重新调整堆
return *this;
}
//------------------------------------------------------------------------- template<class T>
MaxHeap<T>& MaxHeap<T>::DeleteMax( T& value )
{
if(CurrentSize==0)
{
cout<<"错误:堆空."<<endl;
throw exception("堆空");
}
value=Data[1];
Data[1]=Data[CurrentSize--];
ModifyDown(1,CurrentSize);//重新调整堆
return *this;
}
//------------------------------------------------------------------------- template<class T>
void MaxHeap<T>::ModifyUp(int start)
{
int i=start;
T x=Data[i];
//当未到达根结点并且start所指节点值大于其父节点时进行移动 while(i!=1&&x>Data[i/2])
{
Data[i]=Data[i/2];//将父节点下移
i/=2;//i指针上移
}
Data[i]=x;
return ;
}
//---------------------------------------------------------------- template<class T>
void MaxHeap<T>::ModifyDown(int start,int end)
{
T x=Data[start];
int c=2*start;
while(c<=end)
{
if(c<end&&Data[c]<Data[c+1]) c++;
if(x>Data[c]) break;
else
{
Data[c/2]=Data[c];//将孩子上移
c*=2;
}//if
}//while
Data[c/2]=x;
}
#endif
class Object{
friend int Knapsack(int*,int*,int,int,int*);
public:
int operator<=(Object a)const
{return (d>=a.d);}
private:
int ID;
float d;//单位重量价值
};
template<class Typew,class Typep>class Knap;
class bbnode{
friend Knap<int,int>;
friend int Knapsack(int*,int*,int,int,int*);
private:
bbnode *parent;//指向父结点的指针
bool LChild;//左儿子结点标志
};
template<class Typew,class Typep>
class HeapNode{
friend Knap<Typew,Typep>;
public:
int operator < (HeapNode a)const {return uprofit<a.uprofit;} int operator > (HeapNode a)const {return uprofit>a.uprofit;} private:
Typep uprofit,//结点的价值上界
profit;//结点所相应的价值
Typew weight;//结点所相应的重量
int level;//活结点在子集树中所处的层序号
bbnode *ptr;//指向活结点在子集树中相应结点的指针
};
template<class Typew,class Typep>
class Knap{
friend Typep Knapsack(Typep*,Typew*,Typew,int,int*);
public:
Typep MaxKnapsack();
private:
MaxHeap<HeapNode<Typep,Typew>> *H;
Typep Bound(int i);
void AddLiveNode(Typep up,Typep cp,Typew cw,bool ch,int level); bbnode* E;//指向扩展结点的指针
Typew c;//背包容量
int n;//物品总数
Typew *w;//物品数组
Typep *p;//物品价值数组
Typew cw;//当前装包重量
Typep cp;//当前装包价值
int *bestx;//最优解
};
template<class Typew,class Typep>
Typep Knap<Typew,Typep>::Bound(int i)
{//计算结点所相应价值的上界
Typew cleft=c-cw;//剩余容量
Typep b=cp;//价值上界
//以物品单位重量价值递减序装填剩余容量
while(i<=n&&w[i]<=cleft){
cleft-=w[i];
b+=p[i];
i++;
}
//装填剩余容量装满背包
if(i<=n) b+=p[i]/w[i]*cleft;
return b;
}
template<class Typep,class Typew>
void Knap<Typep,Typew>::AddLiveNode(Typep up,Typep cp,Typew cw,bool ch,int lev)
{//将一个新的活结点插入到子集树和最大堆H中
bbnode *b=new bbnode;
b->parent=E;
b->LChild=ch;
HeapNode<Typep,Typew>N;
N.uprofit=up;
N.profit=cp;
N.weight=cw;
N.level=lev;
N.ptr=b;
H->Insert(N);
}
void Sort(Object *Q,int len)
{
for(int i=0;i<len;i++)
for(int j=0;j<len;j++)
if(Q[i]<=Q[j])
{
Object temp=Q[i];
Q[i]=Q[j];
Q[j]=temp;
}
}
template<class Typew,class Typep>
Typep Knap<Typew,Typep>::MaxKnapsack()
{//优先队列式分支界限法，返回最大价值，bestx返回最优解 //定义最大堆的容量为1000
H=new MaxHeap<HeapNode<Typep,Typew>>(1000); //为bestx分配存储空间
bestx=new int[n+1];
//初始化
int i=1;
E=0;
cw=cp=0;
Typep bestp=0;//当前最优值
Typep up=Bound(1);//价值上界
//搜索子集空间树
while(i!=n+1){//非叶结点
//检查当前扩展结点的左儿子结点
Typew 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=Bound(i+1);
//检查当前扩展结点的右儿子结点
if(up>=bestp)//右子树可能含最优解
AddLiveNode(up,cp,cw,false,i+1);
//取下一扩展结点
HeapNode<Typep,Typew>N;
H->DeleteMax(N);
E=N.ptr;
cw=N.weight;
cp=N.profit;
up=N.uprofit;
i=N.level;
}
//构造当前最优解
for(int j=n;j>0;j--){
bestx[j]=E->LChild;
E=E->parent;
}
return cp;
}
template<class Typew,class Typep>
Typep Knapsack(Typep p[],Typew w[],Typew c,int n,int bestx[]) {//返回最大价值，bestx返回最优解
//初始化
Typew W=0;//装包物品重量
Typep P=0;//装包物品价值
//定义依单位重量价值排序的物品数组
Object *Q=new Object[n];
for(int i=1;i<=n;i++){
//单位重量价值数组
Q[i-1].ID=i;
Q[i-1].d=1.0*p[i]/w[i];
P+=p[i];
W+=w[i];
}
if(W<=c) return P;//所有物品装包
//依单位重量价值排序
Sort(Q,n);
//创建类Knap的数据成员
Knap<Typew,Typep>K;
K.p=new Typep[n+1];
K.w=new Typew[n+1];
for(int i=1;i<=n;i++){
K.p[i]=p[Q[i-1].ID];
K.w[i]=w[Q[i-1].ID];
}
K.cp=0;
K.cw=0;
K.c=c;
K.n=n;
//调用MaxKnapsack求问题的最优解
Typep bestp=K.MaxKnapsack();
for(int j=1;j<=n;j++)
bestx[Q.[j-1].ID]=K.bestx[j];
delete [] Q;
delete [] K.w;
delete [] K.p;
deltet [] K.bestx;
return bestp;
}
int main()
{
int n,c,i,value;
FILE *fp;
FILE *ptr;
int *x,*w,*v;
fp=fopen("D:\\bag.txt","r"); if(!fp)
{
printf("file cannot be opened"); exit(1);
}
fscanf(fp,"%Ld%Ld",&c,&n);
x=new int[n+1];
w=new int[n+1];
v=new int[n+1];
for(i=1;i<=n;i++)
{
x[i]=0;
fscanf(fp,"%Ld%Ld",&w[i],&v[i]); }
value=Knapsack(v,w,c,n,x);
//cout<<value<<endl;
/*int va=0;
for(i=1;i<=n;i++)
if(x[i])
va+=v[i];
cout<<va<<endl;
*/
ptr=fopen("D:\\result.txt", "w"); fprintf(ptr,"%d\n",value);
for(i=1;i<=n;i++)
fprintf(ptr,"%d %d\n",i,x[i]);
fclose(fp);
fclose(ptr);
return 0;
}