回朔法之0_1背包

o_1背包用回朔法求解时，其解空间是子集树。

回朔法从开始节点（根节点）出发，以深度优先方式搜索整个解空间。这个开始节点成为活结点，同时也成为当前的扩展节点，在当前的扩展节点处，向纵深方向搜索至一个新节点，这个新节点也就成为了新的活结点，并成为当前扩展节点。如果当前扩展节点处不能在向纵深方向移动，则当前扩展节点也就成为死结点。

此时，应往回移动（回朔）至最近的一个活结点处，并使这个活结点成为当前的扩展节点。

回朔法以这种方式递归的在解空间中搜索，直到找到所要求的解或解空间中已无活结点时为止。

//0-1背包问题 回溯法求解
#include <iostream>
using namespace std; 

template<class Typew,class Typep>
class Knap
{
	template<class Typew,class Typep>
	friend Typep Knapsack(Typep [],Typew [],Typew,int);
	public:
		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 = 3;//物品数
	int c = 30;//背包容量
 	int p[] = {0,40,25,25};//物品价值 下标从1开始
	int w[] = {0,16,15,15};//物品重量 下标从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;
}

/*

最坏有2^n即所有节点都计算下上界，故总的时间复杂度O(n*2^n)
*/
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);
 	}
}
/**

  计算上界O(n)的时间复杂度
*/

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*1.0;
   }

   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);           //为了便于在排序，便重载了object类的比较运算符
   
	for( i=1; i<=n; i++)
	{
		cout<<Q[i-1].ID <<endl;
	    cout<<Q[i-1].d<<endl;
	}

	//进行回朔前的准备
	Knap<Typew,Typep> K;
	K.p = new Typep[n+1];
	K.w = new Typew[n+1];

	for(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; j++)  
		{  
			if(a[i]<=a[j])  
			{  
				Swap(a[i],a[j]); 
				exchange = true;  
			}   
		}   
		//如果这次遍历没有元素的交换,那么排序结束   
		if(false == exchange)  
		{
			  break ;  
		}
	 }
}
template <class Type>
inline void Swap(Type &a,Type &b)
{
	Type temp = a;
	a = b;
	b = temp;
}

ps：每次往0分支走时，都会先计算下一层的上界bound（i+1),如果大于bestp，继续深度扩展，否则向上回朔,直到解空间中再无扩展节点。