回朔法之0_1背包

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

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

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

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

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

template
class Knap
{
	template
	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
Typep Knapsack(Typep p[],Typew w[],Typew c,int n);

template 
inline void Swap(Type &a,Type &b);

template
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<<"背包容量为："<
void Knap::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
Typep Knap::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           //这样写也可以！！！！！！！
	friend Typep Knapsack(Typep[],Typew [],Typew,int);
	public:
		int operator <= (Object a)const
		{
			return (d<=a.d);
		}
	private:
		int ID;
		float d;	
};

template
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< 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
void BubbleSort(Type a[],int n)
{
		 //记录一次遍历中是否有元素的交换   
     bool exchange;               //这个的设定的确精辟
	 for(int i=0; i
inline void Swap(Type &a,Type &b)
{
	Type temp = a;
	a = b;
	b = temp;
}

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