回溯法(Back tracking)

回溯法有着通用解题法之称，是一种带优化的穷举式搜索

搜索策略是DFS(Depth First Search)即深度优先搜索

回溯法适合求解所有解或最优解

3.1概念

3.1.1问题的解空间

问题的解一般表示为：X={x1,x2,...,xn}其中分量xi表示第i步的操作

显约束：对分量xi取值范围的限定

隐约束：对不同分量之间施加的约束

所有满足约束条件的解向量构成了问题的解空间

问题的解空间一般以树的形式来表示

3.1.1.1子集树

所给问题是从n个元素的集合中找出满足某种性质的子集时，相应的解空间树称为子集树（二叉的）

3.1.1.2排列树

所给问题是从n个元素的集合中找出满足某种性质的排列时，相应的解空间树称为排列树

3.1.1.3m叉树

所给问题的n个元素中，每个元素均有m种选择，即寻找满足某种特性的n个元素取值的一种组合，相应的解空间称为m叉树

3.1.2如何做

扩展结点：一个正在产生儿子的结点

活结点：一个自身已经生成，但儿子还没有全部生成的结点

死结点：一个所有儿子已经生成的结点

如何扩展，即得到每一步的解（How to do？）

while(还存在活结点并且还没找到要求的解)
{ if(在当前的扩展结点处，可以向纵深方向移至一个新结点)
     移至新结点进行解的判断；
 else
     当前的扩展结点成为死结点;
    往回移动(回溯)至最近的一个活结点;
    使这个活结点成为当前的扩展结点;
 }

 用回溯法搜索子集树和m叉树的算法框架

void backtrack (int t){
    if (t>n) output(x);
    else
    for (i=下界; i<=上界; i++) {
       x[t]=i;
       if ( legal(t) ) //剪枝
       backtrack(t+1);
    }
}

用回溯法搜索排列树的算法框架

void backtrack (int t){
    if (t>n) output(x);
    else
    for (int i=t;i<=n;i++){
       swap(&x[t]， &x[i]);
       if (legal(t)) backtrack(t+1);
       swap(&x[t]， &x[i]);
    }
}

对于排列树来说，我个人理解就是通过不断地交换生成所有可能的解，然后进行求解的过程。

交换的过程类似于递归那一章所说的求n位数的全排列问题

例题：

 3.1.3剪枝函数

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

限界函数：剪去不能得到最优解的子树

回溯法的关键就是设计合适的剪枝函数

3.1.4总结

回溯法其实就是不断地试探，看前方的路是否可以走，如果不行就退回一步，再换一个办法

3.2回溯法问题实例 

3.2.1 0/1背包问题

这个问题非常经典，希望大家和我都能弄清

问题描述：有n个重量分别为{w1，w2， … ，wn}的 物品，它们的价值分别为{v1，v2， … ，vn}，给定一 个容量为 C 的背包。求能装进背包价值最大的物品们

通过读题，明确约束

1.确定解空间

数组x表示最优解，op表示当前解

op[i]=1表示第i个物品被选中

op[i]=0表示第i个物品未被选中

2.选用合适的结构：子集树

对于第i层上的某个结点，对应的状态为dfs(i,tw,tv,op)

其中tw表示当前装入背包中的物品总重量，tv表示当前背包中物品总价值，op为当前解向量

下面来看一个具体的例子

那么咱们可以列出所有情况，找到最优解

 

编程实现如下：
 

int n=4; //4种物品
int C=6; //限制重量为6
int w[]= {0,5,3,2,1}; //存放4个物品重量
int v[]= {0,4,4,3,1}; //存放4个物品价值
//求解结果表示
int x[MAXN]; //存放最终解
int maxv; //存放最优解的总价值
void dfs(int i,int tw,int tv,int op[]) {
	if (i>n) { //找到一个叶子结点
		if (tw<=C && tv>maxv) { //找到一个满足条件的更优解,保存
			maxv=tv;
			for (int j=1; j<=n; j++)
				x[j]=op[j];
		}
	} else { //尚未找完所有物品
		op[i]=1; //选取第i个物品
		dfs(i+1,tw+w[i],tv+v[i],op);
		op[i]=0; //不选取第i个物品,回溯
		dfs(i+1,tw,tv,op);
	}
}

在代码中，通过不断的递归，当i>n时，即到了叶子结点，然后判断是否为更优解，并保存

若i<n，则在当前节点，需要有选择当前物品和不选择当前物品两种情况，因此设置op[i]=1和op[i]=0来进行整个过程，直到找到最优解。

上述函数实现了我们想要的功能，但是却十分的麻烦，倘若第一条路径就是最优解，岂不是要白白浪费许多时间去做没有必要的事情，因此我们应该设计合适的剪枝函数来优化我们的算法。

剪枝函数分为约束函数和限界函数两种

约束函数：剪去不满足约束条件的分支。对于第i层的有些 结点，如果tw+w[i] >= W，则扩展是没有必要的。

else //尚未找完所有物品
if ( tw+w[i]<=C ) //左子树结点剪枝
{   op[i]=1; //选取第i个物品
    dfs(i+1,tw+w[i],tv+v[i],op);
}

限界函数：剪去得不到最优解的分支。如果当前价值+未选择的所有物品的价值 < 现有最优解的价值，也不用扩展这样的结点。

if ( tv+rv-v[i]> maxV )
{   op[i]=0; //不选取第i个物品
    dfs(i+1,tw,tv,rv-v[i],op);
}

 因此优化后的算法如下：

void dfs(int i,int tw,int tv,int rv,int op[]) {
	//初始调用时rw为所有物品重量和
	int j;
	if (i>n) { //找到一个叶子结点
		if (tw<=C && tv>maxv) { //找到一个满足条件的更优解,保存
			maxv=tv;
			for (j=1; j<=n; j++) //复制最优解
				x[j]=op[j];
		}
	} else { //尚未找完所有物品
		if (tw+w[i]<=C && tv+rv > maxV) { //左孩子结点剪枝
			op[i]=1; //选取第i个物品
			dfs(i+1,tw+w[i],tv+v[i],rv-v[i],op);
		}
		if ( tv+rv-v[i]> maxV ) {
			op[i]=0; //不选取第i个物品
			dfs(i+1,tw,tv,rv-v[i],op);
		}
	}
}

3.2.2哈密尔顿回路

问题描述：1859 年，爱尔兰数学家哈密尔顿（Hamilton）提出了一个“周游世界”的游戏：在一个正十二面体的二十个顶点上，标注了一些世界著名城市，正十二面体的棱表示连接着这些城市的路线。要求游戏参与者从某个城市出发，把所有的城市都走过一次，且仅走过一次，然后回到出发点。

1.确定解空间

用数组x[n]表示该问题的一组解，x[i]表示在第i次访 问的结点号。

2.确定解空间树的结构

所给问题是从n个元素的集合中找出满足某种性质的排列，因此，解空间可以组成一棵排列树，结点总数为n!。

3.搜索解空间树

第t步，对x[t]进行决策：

当t=n时,当前扩展结点是叶结点。此时需要检测无向图G是否存在一条从顶点x[n]到顶点x[1]的边，如果存在，则找到一条哈密顿回路；否则回溯。

当t<n时，当前扩展结点位于排列树的第t层，即对第k步进行决策。若图G中存在从顶点x[t-1]到x[t]的路径时，x[1:t]就构成了图G的一部分路径

4.算法实现

void hamilton(int t) {
	if( t==n && g[ x[t] ][ x[1] ]==1 )
		output(x);
	else
		for(int i=t; i<=n; i++) {
			swap(&x[t], &x[i]);
			if( g[ x[t] ][ x[t-1] ]==1 ) //剪枝函数
				hamilton(t+1);
			swap(&x[i], &x[t]);
		}
}

若为最小费用的哈密尔顿回路（也称为旅行商问题）

问题描述：一个商品推销员要去若干个城市推销商品，该推销员从一个城市出发，需要经过所有城市后，回到出发地。应如何选择行进路线，以使总的行程最短。

void backtrack(int t) {
	if(t==n) {
		if(a[x[n]][x[1]]==1 &&
		        (cc+a[x[n]][x[1]])<bestc)) {
			for(int j=1; j<=n; j++)
				bestx[j]=x[j];//最优解
			bestc=cc+a[x[n]][x[1]];
		}
	} else {
		for(int i=t; i<=n; i++)
			if(a[x[t]][x[t-1]]==1 && cc+a[x[t]][x[t-1]] < bestc) ) {
				swap(&x[t], &x[i]);
				cc += a[x[t]][x[t-1]];
				backtrack(t+1); //递归
				cc -= a[x[t]][x[t-1]]; //回溯
				swap(&x[t], &x[i]);
			}
	}
}

3.2.3活动安排

假设有一个需要使用某一资源的n个活动所组成的集合S，S={1， … ，n}。该资源任何时刻只能被一个活动所占用，活动i有一个开始时间bi和结束时间ei（bi<ei),其执行时间为ei-bi。

 

 

typedef struct Action {
	int b; //活动起始时间
	int e; //活动结束时间
} Action;
int n=4;
Action A[]= {
   {0,0},{1,3},{2,5},{4,8},{6,10}}; //下标0不用
int x[MAX]; //临时解向量
int bestx[MAX]; //最优解向量
int laste=0; //当前调度方案中最后兼容活动的结束时间, 初值为0
int sum=0; //当前调度方案中所有兼容活动个数, 初值为0
int maxsum=0; //调度方案数目前最优值
void dfs(int t) { //搜索活动问题最优解
	if (t>n) { //到达叶子结点,产生一种调度方案
		if (sum>maxsum) {
			maxsum=sum;
			for (int i=1; i<=n; i++)
				bestx[i]=x[i];
		}
	} else {
		for(int i=t; i<=n; i++) { //没有到达叶子结点,考虑i到n的活动
			//第t层结点选择活动x[t]
			swap(&x[t],&x[i]); //生成一种新排列
			int tmpSum=sum; //保存sum，laste以便回溯
			int tmpLaste=laste;
			if (A[x[i]].b>=laste) { //活动x[i]与前面兼容
				sum++; //兼容活动个数增1
				laste=A[x[i]].e; //修改本方案的最后兼容时间
				dfs(t+1); //排序树问题递归框架:进入下一层
			}
			swap(&x[t],&x[i]); //排序树问题递归框架:交换x[i],x[t]
			sum=tmpSum; //回溯
			laste=tmpLaste; //即撤销第t层结点对活动x[t]的选择
		}
	}
}

3.3总结

解题步骤：

1.定义问题的解空间（描述解）：用一个什么样的向量表示问题的解？该向量中的每个变量如何取值？

2.确定解空间的结构：子集树？排列树？以及每个节点和边的含义

3.确定剪枝函数，以深度优先搜索解空间