回溯算法

                                **  回溯算法**

以深度优先的方式系统地搜索问题的解的方法称为回溯法。
可以系统地搜索一个问题的所有解或任意解。
有许多问题，当需要找出它的解集或者要求回答什么解是满足某些约束条件的最佳解时，往往要使用回溯法。
回溯法的基本做法是搜索，或是一种组织得井井有条的，能避免不必要搜索的穷举式搜索法。

应用回溯法求解时，需要明确定义问题的解空间。
问题的解空间应至少包含问题的一个（最优）解。
例如，对于有n种可选择物品的0-1背包问题，其解空间由长度为n的0-1向量组成，该解空间包含了对变量的所有可能的0-1赋值。

解空间的特点：
（完全）二叉树.
问题的解是一棵子树（一条路）
通过深度优先搜索获得最优解
在生成解空间树时，定义以下几个相关概念：
活结点：
如果已生成一个结点而它的所有儿子结点还没有全部生成，则这个结点叫做活结点。
扩展结点：
当前正在生成其儿子结点的活结点叫扩展结点（正扩展的结点）。
死结点：
不能再进一步扩展或者其儿子结点已全部生成的结点就是死结点。

回溯从开始结点（根结点）出发，以深度优先的方式搜索整个解空间。
开始结点(根结点)成为第一个活结点，同时成为当前的扩展结点。
在当前的扩展结点，搜索向深度方向进入一个新的结点。这个新结点成为一个新的活结点，并成为当前的扩展结点。
若在当前扩展结点处不能再向深度方向移动，则当前的扩展结点成为死结点，即该活结点成为死结点。
此时回溯到最近的一个活结点处，并使得这个活结点成为当前的扩展结点。
回溯法以这样的方式递归搜索整个解空间（树），直至满足中止条件。

例6.2 旅行商问题
TSP问题(Traveling Salesman Problem)通常称为旅行商问题，也称为旅行售货员问题、货担郎问题等，是组合优化中的著名难题，也是计算复杂性理论、图论、运筹学、最优化理论等领域中的一个经典问题，具有广泛的应用背景。

问题的一般描述为：旅行商从n个城市中的某一城市出发，经过每个城市仅有一次，最后回到原出发点，在所有可能的路径中求出路径长度最短的一条。

在回溯法搜索解空间树时，通常采用两种策略（剪枝函数）避免无效搜索以提高回溯法的搜索效率：
用约束函数在扩展结点处剪去不满足约束条件的子树；
用限界函数剪去不能得到最优解的子树。
解0—1背包问题的回溯法用剪枝函数剪去导致不可行解的子树。
解旅行商问题的回溯算法中，如果从根结点到当前扩展结点的部分周游路线的费用已超过当前找到的最好周游路线费用，则以该结点为根的子树中不包括最优解，就可以剪枝。

子集树与排列树

有时问题是要从一个集合的所有子集中搜索一个集合，作为问题的解。或者从一个集合的排列中搜索一个排列，作为问题的解。
回溯算法可以很方便地遍历一个集合的所有子集或者所有排列。
当问题是要计算n个元素的子集，以便达到某种优化目标时，可以把这个解空间组织成一棵子集树。
例如，n个物品的0-1背包问题相应的解空间树就是一棵子集树。
这类子集树通常有2n个叶结点，结点总数为2n +1-1。
遍历子集树的任何算法，其计算时间复杂度都是Ω(2n)。

void backtrack (int t){  //形参t为树的深度，根为1
　　if (t>n) 
	update(x);   //扩展到叶子结点，得到了一组解决方案
　　else  
　　　　for (int i=0; i<=1; i++)　　//每个结点只有两个子树
　　　　{
　　　　　　x[t]=i;　　　  //即0/1，表示第  t个元素是否是可选元素
　　　　　　if (constraint(t) && bound(t)) //判断当前结点是否是扩展结点
		backtrack(t+1); //对当前结点按照深度优先搜索的方式进行扩展
　　　　}
}

回溯算法搜索排列树的伪代码

void backtrack (int t){
　　if (t>n)
             update(x); //得到了一个全排列，对排列结果进行更新
　　else
　　　　for (int i=t; i<=n; i++)　　　　{
　　　　　　//为了保证排列中每个元素不同，通过交换 来实现
　　　　　　swap(x[t], x[i]);
　　　　　　if (constraint(t) && bound(t))   
                         backtrack(t+1);
　　　　　　swap(x[t], x[i]);　　　　//恢复状态
　　　　}
}

【例1】素数环:从1到20这20个数摆成一个环，要求相邻的两个数的和是一个素数。
【算法分析】
从1开始，每个空位有20种可能，只要填进去的数合法：
与前面的数不相同；
与左边相邻的数的和是一个素数。
第20个数还要判断和第1个数的和是否素数。

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cmath>
using namespace std;
bool b[21]={0};   //判断i是否出现在素数环中
int total=0,a[21]={0}; //a记录素数环中的每一个数
int search(int  t);           //回溯过程。形参表示素数环中的数的编号
int print();                  //输出方案
bool pd(int,int);         //判断素数
int search(int t){  //寻找所有解
    int i;
    for (i=1;i<=20;i++)          //有20个数可选
     if (pd(a[t-1],i)&&(!b[i])){ //判断与前一个数是否构成素数及该数是否可用
         a[t]=i;  //素数环中的第t个数
         b[i]=1;  //i进入素数环
         if (t==20) {  //一个解
	 if (pd(a[20],a[1])) print();}
          else 
	search(t+1);
         b[i]=0;
      }
}
 int main(){
    search(1);
    cout<<total<<endl;                    //输出总方案数
}
int print(){
   total++;
   cout<<"<"<<total<<">";
   for (int j=1;j<=20;j++)
     cout<<a[j]<<" ";
   cout<<endl; 
  }
bool pd(int x,int y){
    int k=2,i=x+y;
    while (k<=sqrt(i)&&i%k!=0) k++;
    if (k>sqrt(i)) return 1;
    else return 0;
}

【例2】设有n个整数的集合｛1,2,…,n｝，从中取出任意r个数进行排列（r<n），试列出所有的排列。
3个数全排列的搜索空间

#include<cstdio>
#include<iostream>
#include<iomanip>
using namespace std;
int num=0,a[10001]={0},n,r;
bool b[10001]={0};
int search(int);      //回溯过程
int print();              //输出方案
int main(){
   cout<<"input n,r:";
   cin>>n>>r;
   search(1);
   cout<<"number="<<num<<endl;    //输出方案总数
}
int search(int k){
    int i;
    for (i=1;i<=n;i++)
     if  (!b[i]) {                                //判断i是否可用
         a[k]=i;                               //保存结果
         b[i]=1;
         if (k==r) 
	print();
         else 
	search(k+1);
       b[i]=0; 
      }
}
int print(){
  num++;
  for (int i=1;i<=r;i++)
    cout<<setw(3)<<a[i];
  cout<<endl; 
}

【例3】任何一个大于1的自然数n，总可以拆分成若干个小于n的自然数之和。

当n=7共14种拆分方法：
7=1+1+1+1+1+1+1
7=1+1+1+1+1+2
7=1+1+1+1+3
7=1+1+1+2+2
7=1+1+1+4
7=1+1+2+3
7=1+1+5
7=1+2+2+2
7=1+2+4
7=1+3+3
7=1+6
7=2+2+3
7=2+5
7=3+4
total=14

#include<cstdio>
#include<iostream>
#include<cstdlib>
using namespace std;
int a[10001]={1},n,total;
int search(int  s ,int  t); // s 代表待拆分的数； 序列中t 代表拆分序列中的数的编号
int print(int);
int main(){
    cin>>n;
    search(n,1);          //将要拆分的数n传递给s
    cout<<"total="<<total<<endl;        //输出拆分的方案数
}
int search(int s,int t){
    int i;
    for (i=a[t-1];i<=s;i++)//后面的加数不小于前面的加数
     if (i<n) { //当前数i要大于等于前1位数，且不过n
       a[t]=i;  //保存当前拆分的数i
       s-=i; 	//s减去数i， s的值将继续拆分
       if (s==0) 
	print(t);             //当s=0时，拆分结束输出结果
         else 
	search(s,t+1);       //当s>0时，继续递归
       s+=i;    //回溯：加上拆分的数，以便产生所有可能的拆分
      }
}
int print(int t){
    cout<<n<<"=";
    for (int i=1;i<=t-1;i++)                  //输出一种拆分方案
      cout<<a[i]<<"+";
    cout<<a[t]<<endl;
    total++;                                  //方案数累加1
}

装载问题

给定n个集装箱要装上一艘载重量为c的轮船，其中集装箱i的重量为wi。集装箱装载问题要求确定在不超过轮船载重量的前提下，将尽可能多的集装箱装上轮船（贪心算法中的装载问题讨论的是装载件数；本题讨论的是最大装载重量。）
由于集装箱问题是从n个集装箱里选择一部分集装箱，假设解向量为X(x1, x2, …, xn)，其中xi∈{0, 1}， xi =1表示集装箱i装上轮船， xi =0表示集装箱i不装上轮船。
输入
每组测试数据：第1行有2个整数c和n。C是轮船的载重量（0＜c＜30000），n是集装箱的个数（n≤20）。第2行有n个整数w1, w2, …, wn，分别表示n个集装箱的重量。
输出
对每个测试例，输出两行：第1行是装载到轮船的最大载重量，第2行是集装箱的编号。

输入样例
34 3
21 10 5
输出（考虑最大装载量的最优解）
31（重量）
1 2

考虑最大装载件数的最优解
2（件）
5 10

该问题的形式化描述为：

用回溯法解装载问题时，其解空间是一棵子集树，与0 - 1背包问题的解空间树相同。

可行性约束函数可剪去不满足约束条件的子树：

令cw(t)表示从根结点到第t层结点为止装入轮船的重量，即部分解(x1, x2 , …, xt)的重量：

当cw(t)>c时，表示该子树中所有结点都不满足约束条件，可将该子树剪去。

#include <iostream>
using namespace std;
class goods{
	int weight;
public:
	goods(int w=0):weight(w)
	{}
	int get_w(){
		return weight;
	}
	void set(int w){
		weight=w;
	}
	
};
//goods *g,集装箱列表
 //int *best,待求解的最优装载方案
 //int t,子集树数的层号。根节点在第0层，叶节点在第n层
 //int n,集装箱的总数
//int &cw, 当前的轮船的荷载
//int bestcw ,当前的最大荷载
//int *x,满足当前最大荷载的装载方案
//int r剩余的集装箱重量和
void load(goods *g, int *x, int t, int n,int cw, int &bestcw ,int *best,int r,int c){
	if(t>n) {     //已经遍历的到叶子结点，得到了一个解决方案
	    if(cw>bestcw)	{
		for(int i=0;i<n;i++)
	       	    best[i]=x[i];
		    bestcw=cw;
		}
	}	
	 else{ //每个结点可以有两个分支，分别利用约束规则和限界规则进行剪枝
	r=r-g[t].get_w();//剩余未处理的物品的重量和，与是否选取当前物品无关
	if(cw+g[t].get_w()<=c){ //  根据题意中的约束条件进行剪枝
	  	x[t]=1;
		cw=cw+g[t].get_w(); //当前装入的物品的重量和
		load(g,x,t+1,n,cw,bestcw,best,r,c);
		cw=cw-g[t].get_w(); //回溯的需要
	}
	if(cw+r>bestcw) {    //限界规则
		x[t]=0;
		load(g,x,t+1,n,cw,bestcw,best,r,c);
	}
	r=r+g[t].get_w(); //回溯的需要
      }
   }
   int main(){
	int n,c,bestcw=0;
	int *x,*best, r=0;
	cout<<“请输入物品的件数和轮船的装载重量：";
	cin>>n>>c;
	goods *g;
	g=new goods[n];
	x=new int [n];
	best=new int[n];
	cout<<"请输入每件物品的重量：";
	for(int i=0;i<n;i++)	{
		int w;	cin>>w;  g[i].set(w);r=r+w;
	}
	load(g,x,0,n,0,bestcw,best,r,c);
	cout<<bestcw<<endl;
	for(i=0;i<n;i++)
		cout<<best[i]<<"  ";
	cout<<endl;
	return 0;
}

0－1背包问题

给定一个物品集合s＝｛1，2，3，…，n｝，物品i的重量是wi，其价值是vi，背包的容量为W，即最大载重量不超过W。在限定的总重量W内，我们如何选择物品，才能使得物品的总价值最大。
输入
第一个数据是背包的容量为c（1≤c≤1500），第二个数据是物品的数量为n（1≤n≤50）。接下来n行是物品i的重量是wi，其价值为vi。所有的数据全部为整数，且保证输入数据中物品的总重量大于背包的容量。
当c＝0时，表示输入数据结束。
输出：对每组测试数据，输出装入背包中物品的最大价值。

令cw(i)表示目前搜索到第i层已经装入背包的物品总重量，即部分解(x1, x2 , …, xi)的重量：

对于左子树， xi =1 ，其约束函数为：

若constraint(i)＞W，则停止搜索左子树，否则继续搜索。

对于右子树，为了提高搜索效率，采用限界函数Bound(i)剪枝。
令cv(i)表示目前到第i层结点已经装入背包的物品价值：

令r(i)表示剩余物品的总价值：

则限界函数Bound(i)为：

假设当前最优值为bestv，若Bound(i)＜bestv，则停止搜索第i层结点及其子树，否则继续搜索。
显然r(i)越小， Bound(i)越小，剪掉的分支就越多（在高层剪枝，剪掉的分支越多。从而能加快搜索速度）。
为了构造更小的r(i) ，将物品以单位重量价值比di=vi/wi递减的顺序进行排列（贪心策略）：
d1≥d2≥… ≥dn
对于第i层，背包的剩余容量为W-cw(i)，采用贪心算法把剩余的物品放进背包。

为什么没有按照重量进行排序呢？

0-1背包问题的目标是：
在不超重的前提下计算背包内物品的最大价值
因此，贪心策略是：
按照单位价值由大到小进行处理
物品的价值会对限界函数产生影响
物品的重量会对约束函数产生影响
由于根据物品价值制定贪心策略
所以，通过单位价值排序，加速剪枝

#define NUM 100
int c;				//背包的容量
int n;				//物品的数量
int cw;				//当前重量
int cv;				//当前价值
int bestv;			//当前最优价值
//描述每个物品的数据结构
struct Object{
	int w;			//物品的重量
	int v;			//物品的价值
	double d;		//物品的单位重量价值比
}Q[NUM];			//物品的数组

对物品以单位重量价值比递减排序的因子是：
bool cmp(Object a, Object b)
{
	if(a.d>=b.d) return true;
	else return false;
}
物品的单位重量价值比是在输入数据时计算的：
for(int i=0; i<n; i++)
{
	scanf("%d%d",&Q[i].w,&Q[i].v);
	Q[i].d = 1.0*Q[i].v/Q[i].w;
}
使用C++标准模板库的排序函数sort()排序：
sort(Q, Q+n, cmp);
//形参i是回溯的深度，从0开始.商品编号从0开始编号
void backtrack(int i){
　　if (i+1>n) {bestv = cv; return;}
　　//进入左子树搜索, 表示选择第i件物品 
　　if (cw+Q[i].w<=c){　//约束条件
　　　　　　cw += Q[i].w;   //选择第i件物品 ,导致相关的数据发生变化
　　　　cv += Q[i].v;	 //选择第i件物品 ,导致相关的数据发生变化
　　　　backtrack(i+1);
　　　　cw -= Q[i].w;	 //回溯的需要，恢复数据
　　　　cv -= Q[i].v;	 //回溯的需要，恢复数据
　　}
　　//进入右子树搜索，表示不选择第i件物品，相关的cw, cv不改变
　　if (Bound(i+1)>bestv) backtrack(i+1);
}
//形参i是回溯的深度
int Bound(int i){
　　int cleft = c-cw;　　　//背包剩余的容量
　　int b = cv;　　　　　　//上界
　　//尽量装满背包
　　while (i<n && Q[i].w<=cleft){
　　　　cleft -= Q[i].w;
　　　　b += Q[i].v;
　　　　i++;
　　}
　　//剩余的部分空间也装满。0-1是可能装不满的。但此处主要计算最大值，所以，需要从装满的角度考虑该问题
　　if (i<n) b += 1.0*cleft*Q[i].v/Q[i].w;
　　return b;
}