回溯法和分支限界法解决0-1背包题(精)[精品文档]

0-1背包问题
计科1班朱润华 2012040732
方法1：回溯法
一、回溯法描述：
用回溯法解问题时，应明确定义问题的解空间。

问题的解空间至少包含问题的一个（最优）解。

对于0-1背包问题，解空间由长度为n的0-1向量组成。

该解空间包含对变量的所有0-1赋值。

例如n=3时，解空间为：｛（0，0，0），（0，1，0），（0，0，1），（1，0，0），（0，1，1），（1，0，1），（1，1，0），（1，1，1）｝然后可将解空间组织成树或图的形式，0-1背包则可用完全二叉树表示其解空间给定n种物品和一背包。

物品i的重量是wi，其价值为vi，背包的容量为C。

问:应如何选择装入背包的物品，使得装入背包中物品的总价值最大?
形式化描述：给定c >0, wi >0, vi >0 , 1≤i≤n.要求找一n元向量(x1,x2,…,xn,),
xi∈{0,1}, ? ∑ wi xi≤c,且∑ vi xi达最大.即一个特殊的整数规划问题。

二、回溯法步骤思想描述：
0-1背包问题是子集选取问题。

0-1 背包问题的解空间可以用子集树表示。

在搜索解空间树时，只要其左儿子节点是一个可行节点，搜索就进入左子树。

当右子树中有可能含有最优解时，才进入右子树搜索。

否则，将右子树剪去。

设r是当前剩余物品价值总和，cp是当前价值；bestp是当前最优价值。

当cp+r<=bestp时，可剪去右子树。

计算右子树上界的更好的方法是将剩余物品依次按其单位价值排序，然后依次装入物品，直至装不下时，再装入物品一部分而装满背包。

例如：对于0-1背包问题的一个实例，n=4,c=7,p=[9,10,7,4],w=[3,5,2,1]。

这4个物品的单位重量价值分别为[3,2,3,5,4]。

以物品单位重量价值的递减序装入物品。

先装入物品4，然后装入物品3和1.装入这3个物品后，剩余的背包容量为1，只能装0.2的物品2。

由此得一个解为[1,0.2,1,1]，其相应价值为22。

尽管这不是一个可行解，但可以证明其价值是最优值的上界。

因此，对于这个实例，最优值不超过22。

在实现时，由Bound计算当前节点处的上界。

类Knap的数据成员记录解空间树中的节点信息，以减少参数传递调用所需要的栈空间。

在解空间树的当前扩展节点处，仅要进入右子树时才计算上界Bound,以判断是否可将右子树剪去。

进入左子树时不需要计算上界，因为上界预期父节点的上界相同。

三、回溯法实现代码：
#include "stdafx.h"
#include <iostream>
using namespace std;
template<class Typew,class Typep>
class Knap
{
template<class Typew,class Typep>
friend Typep Knapsack(Typep [],Typew [],Typew,int);
private:
Typep Bound(int i);
void Backtrack(int i);
Typew c; //背包容量
int n; //物品数
Typew *w; //物品重量数组
Typep *p; //物品价值数组
Typew cw; //当前重量
Typep cp; //当前价值
Typep bestp;//当前最后价值
};
template<class Typew,class Typep>
Typep Knapsack(Typep p[],Typew w[],Typew c,int n);
template <class Type>
inline void Swap(Type &a,Type &b);
template<class Type>
void BubbleSort(Type a[],int n);
int main()
{
int n = 4;//物品数
int c = 7;//背包容量
int p[] = {0,9,10,7,4};//物品价值下标从1开始
int w[] = {0,3,5,2,1};//物品重量下标从1开始
cout<<"背包容量为："<<c<<endl;
cout<<"物品重量和价值分别为："<<endl;
for(int i=1; i<=n; i++)
{
cout<<"("<<w[i]<<","<<p[i]<<") ";
}
cout<<endl;
cout<<"背包能装下的最大价值为："<<Knapsack(p,w,c,n)<<endl; return 0;
}
template<class Typew,class Typep>
void Knap<Typew,Typep>::Backtrack(int i)
{
if(i>n)//到达叶子节点
{
bestp = cp;
return;
}
if(cw + w[i] <= c)//进入左子树
{
cw += w[i];
cp += p[i];
Backtrack(i+1);
cw -= w[i];
cp -= p[i];
}
if(Bound(i+1)>bestp)//进入右子树
{
Backtrack(i+1);
}
}
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;
}
class Object
{
template<class Typew,class Typep>
friend Typep Knapsack(Typep[],Typew [],Typew,int); public: int operator <= (Object a)const
{
return (d>=a.d);
}
private:
int ID;
float d;
};
template<class Typew,class Typep>
Typep Knapsack(Typep p[],Typew w[],Typew c,int n) {
//为Knap::Backtrack初始化
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;
}
//依物品单位重量价值排序
BubbleSort(Q,n);
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;
K.bestp = 0;
//回溯搜索
K.Backtrack(1);
delete []Q;
delete []K.w;
delete []K.p;
return K.bestp;
}
template<class Type>
void BubbleSort(Type a[],int n)
{
//记录一次遍历中是否有元素的交换bool exchange;
for(int i=0; i<n-1;i++)
{
exchange = false ;
for(int j=i+1; j<=n-1; j++)
{
if(a[j]<=a[j-1])
{
Swap(a[j],a[j-1]);
exchange = true;
}
}
//如果这次遍历没有元素的交换,那么排序结束 if(false == exchange)
{
break ;
}
}
}
template <class Type>
inline void Swap(Type &a,Type &b)
{
Type temp = a;
a = b;
b = temp;
}
四、程序运行结果：
五、回溯法解决0-1背包问题复杂度分析：
计算上界需要O(n)时间，在最坏情况下有O(2^n)个右儿子节点需要计算上界，故解0-1背包问题的回溯算法所需要的计算时间为O(n2^n)。

方法2：分支限界法：
一、分支限界法描述：
给定n种物品和一背包。

物品i的重量是wi，其价值为vi，背包的容量为C。

问:应如何选择装入背包的物品，使得装入背包中物品的总价值最大?
形式化描述：给定c >0, wi >0, vi >0 , 1≤i≤n.要求找一n元向量(x1,x2,…,xn,),
xi∈{0,1}, ∋ ∑ wi xi≤c,且∑ vi xi达最大.即一个特殊的整数规划问题。

二、分支限界法步骤思想：
首先，要对输入数据进行预处理，将各物品依其单位重量价值从大到小进行排列。

在优先队列分支限界法中，节点的优先级由已装袋的物品价值加上剩下的最大单位重量价值的物品装满剩余容量的价值和。

算法首先检查当前扩展结点的左儿子结点的可行性。

如果该左儿子结点是可行结点，则将它加入到子集树和活结点优先队列中。

当前扩展结点的右儿子结点一定是可行结点，仅当右儿子结点满足上界约束时才将它加入子集树和活结点优先队列。

当扩展到叶节点时为问题的最优值。

例如：0-1背包问题，当n=3时，w={16,15,15}, p={45,25,25}, c=30。

优先队列式分支限界法：处理法则:价值大者优先。

{}—>{A}—>{B,C}—>{C，D，E}—
>{C，E}—>{C，J，K}—>{C}—>{F，G}—>{G，L，M}—>{G，M}—>{G}—>{N，O}—>{O}—>{}。

三、分支限界法解决0-1背包问题实现代码：
//0-1背包问题分支限界法求解
#include "stdafx.h"
#include "MaxHeap.h"
#include <iostream>
using namespace std;
class Object
{
template<class Typew,class Typep>
friend Typep Knapsack(Typep p[],Typew w[],Typew c,int n, int bestx[]); 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>;
template<class Typew,class Typep>
friend Typep Knapsack(Typep p[],Typew w[],Typew c,int n, int bestx[]); private:
bbnode * parent; //指向父节点的指针
bool LChild; //左儿子节点标识
};
template<class Typew,class Typep>
class HeapNode
{
friend Knap<Typew,Typep>;
public:
operator Typep() const
{
return uprofit;
}
private:
Typep uprofit, //节点的价值上界
profit; //节点所相应的价值
Typew weight; //节点所相应的重量
int level; //活节点在子集树中所处的层序号
bbnode *ptr; //指向活节点在子集中相应节点的指针
};
template<class Typew,class Typep>
class Knap
{
template<class Typew,class Typep>
friend Typep Knapsack(Typep p[],Typew w[],Typew c,int n, int bestx[]); public: Typep MaxKnapsack();
private:
MaxHeap<HeapNode<Typep,Typew>> *H;
Typep Bound(int i);
void AddLiveNode(Typep up,Typep cp,Typew cw,bool ch,int lev);
bbnode *E; //指向扩展节点的指针
Typew c; //背包容量
int n; //物品数
Typew *w; //物品重量数组
Typep *p; //物品价值数组
Typew cw; //当前重量
Typep cp; //当前价值
int *bestx; //最优解
};
template <class Type>
inline void Swap(Type &a,Type &b);
template<class Type>
void BubbleSort(Type a[],int n);
int main()
{
int n = 3;//物品数
int c = 30;//背包容量
int p[] = {0,45,25,25};//物品价值下标从1开始
int w[] = {0,16,15,15};//物品重量下标从1开始
int bestx[4];//最优解
cout<<"背包容量为："<<c<<endl;
cout<<"物品重量和价值分别为："<<endl;
for(int i=1; i<=n; i++)
{
cout<<"("<<w[i]<<","<<p[i]<<") ";
}
cout<<endl;
cout<<"背包能装下的最大价值为："<<Knapsack(p,w,c,n,bestx)<<endl; cout<<"此背包问题最优解为:"<<endl;
for(int i=1; i<=n; i++)
{
cout<<bestx[i]<<" ";
}
cout<<endl;
return 0;
}
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 Typew,class Typep>
void Knap<Typew,Typep>::AddLiveNode(Typep up,Typep cp,Typew cw,bool ch,int lev) {
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);
}
//优先队列式分支限界法，返回最大价值，bestx返回最优解
template<class Typew,class Typep>
Typep Knap<Typew,Typep>::MaxKnapsack()
{
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;
}
//返回最大价值，bestx返回最优解
template<class Typew,class Typep>
Typep Knapsack(Typep p[],Typew w[],Typew c,int n, int 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;//所有物品装包 }
//依单位价值重量排序
BubbleSort(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;
delete []K.bestx;
return bestp;
}
template<class Type>
void BubbleSort(Type a[],int n)
{
//记录一次遍历中是否有元素的交换
bool exchange;
for(int i=0; i<n-1;i++)
{
exchange = false ;
for(int j=i+1; j<=n-1; j++)
{
if(a[j]<=a[j-1])
{
Swap(a[j],a[j-1]);
exchange = true;
}
}
//如果这次遍历没有元素的交换,那么排序结束 if(false == exchange)
{
break ;
}
}
}
template <class Type>
inline void Swap(Type &a,Type &b)
{
Type temp = a;
a = b;
b = temp;
}
四、程序运行结果：
五、分支限界法解决0-1背包问题复杂度分析：
时间复杂度为：O(2^n)；空间复杂度：O(n2^n)。

六、回溯法与分支限界法分析比较：
这两种算法都得到了验证，运行结果证明了算法设计是可行的。

通过对O-1背包问题的算法设计及时间复杂度分析可以看出：无论采用回溯法还是分支限界法，都是在已知约束条件下求解最大值建立数学模型算法实现的过程；但算法具体实现和数据结构的建立要用到递归和栈操作。

比较回溯法和分支限界法，前者的时间复杂度高于后者，从耗费上而言优于后者。

对于回溯法，能够获得最优解，时间复杂度较高，判断右子树时，按效率密度vi/wi对剩余对象排序；对于分支限界法：速度较快，易求解，不过占用的内存较大，效率不高。

成绩单。