回溯法(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.确定剪枝函数,以深度优先搜索解空间