第6章 回溯算法
以深度优先的方式系统地搜索问题的解的方法称为回溯法。
可以系统地搜索一个问题的所有解或任意解。
回溯法的基本做法是搜索,或是一种组织得井井有条的,能避免不必要搜索的穷举式搜索法。
回溯法的基本思想
回溯从开始结点(根结点)出发,以深度优先的方式搜索整个解空间。
开始结点(根结点)成为第一个活结点,同时成为当前的扩展结点。
在当前的扩展结点,搜索向深度方向进入一个新的结点。这个新结点成为一个新的活结点,并成为当前的扩展结点。
若在当前扩展结点处不能再向深度方向移动,则当前的扩展结点成为死结点,即该活结点成为死结点。
此时回溯到最近的一个活结点处,并使得这个活结点成为当前的扩展结点。
回溯法以这样的方式递归搜索整个解空间(树),直至满足中止条件。
在回溯法搜索解空间树时,通常采用两种策略(剪枝函数)避免无效搜索以提高回溯法的搜索效率:
- 用约束函数在扩展结点处剪去不满足约束条件的子树;
- 用限界函数剪去不能得到最优解的子树。
素数环
例1】素数环:从1到20这20个数摆成一个环,要求相邻的两个数的和是一个素数。
【算法分析】
从1开始,每个空位有20种可能,只要填进去的数合法:
- 与前面的数不相同;
- 与左边相邻的数的和是一个素数。
- 第20个数还要判断和第1个数的和是否素数。
素数环(3个数)的解空间(搜索空间)
【算法流程】
1、数据初始化;
2、递归填数:判断第i个数填入是否合法;
A、如果合法:填数;判断是否到达目标(20个已填完):
是,打印结果;不是,递归填下一个;(剪枝条件)
B、如果不合法:选择下一种可能;
#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;
}
装载问题
给定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行是集装箱的编号。
#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时,表示输入数据结束。
通过单位价值排序,加速剪枝
#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;
}
图的m着色问题
给定无向连通图G=(V, E)和m种不同的颜色,用这些颜色为图G的各顶点着色,每个顶点着一种颜色。是否有一种着色法使G中相邻的两个顶点有不同的颜色?
若一个图最少需要m种颜色才能使图中每条边连接的两个顶点着不同颜色,则称这个数m为该图的色数。求一个图的色数m的问题称为图的m可着色优化问题。
图的m着色问题的约束函数是相邻的两个顶点需要着不同的颜色,但是没有限界函数。
#define NUM 100
int n; //图的顶点数量
int m; //可用颜色数量
int a[NUM][NUM]; //图的邻接矩阵
int x[NUM]; //当前的解向量
int sum ; //已经找到的可m着色的方案数量
//形参t是回溯的深度,从1开始
void BackTrack(int t ){
int i;
//到达叶子结点,获得一个着色方案
if( t > n ) {
sum ++ ;
for(i=1; i<=n ;i++)
printf("%d ",x[i]);
printf("\n");
}
else //搜索当前扩展结点的m个孩子
for(i=1; i<=m; i++ ){//尝试每种颜色
x[t] = i;
if( Same(t) ) //判断t 和其邻接点的着色方法是否相同
BackTrack(t+1);
x[t] = 0;//回溯的需要,恢复到未着色的状态
}
}
//形参t是回溯的深度
bool Same(int t)
{
int i;
for(i=1; i<=n; i++ ) //检查t与所有顶点的邻接关系,包括染色和未染色的。
if( (a[t][i] == 1) && (x[i] == x[t]))
return false;
return true;
}
n皇后问题
在n×n格的棋盘上放置彼此不受攻击的n个皇后。
按照国际象棋的规则,皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n皇后问题等价于在n×n格的棋盘上放置n个皇后,任何两个皇后不放在同一行或同一列或同一斜线上。
#define NUM 20
int n; //棋盘的大小
int x[NUM]; //解向量
int sum; //当前已经找到的可行方案数
void Backtrack(int t) {//形参t是回溯的深度,从1开始
int i;
//到达叶子结点,获得一个可行方案。累计总数,并输出该方案
if (t>n) {
sum++; //是全局变量
for (i=1; i<=n; i++)
printf(" %d", x[i]);
printf("\n");
}
else
for (i=1; i<=n; i++) {
x[t] = i;
if (Place(t)) Backtrack(t+1);
}
}
//形参t是回溯的深度
inline bool Place(int t) {
int i;
for (i=1; i<t; i++)
if ((abs(t-i) == abs(x[i]-x[t])) || (x[i] == x[t])) //同一条对角线;同一行
return false;
return true;
}
旅行商问题
是指一销售商从n个城市中的某一城市出发,不重复地走完其余n-1个城市并回到原出发点,在所有可能的路径中求出路径长度最短的一条。本题假定该旅行商从第1个城市出发。
输入
对每个测试例,第1行有两个整数:n(4≤n≤10)和m(4≤m≤20 ) ,n是结点数,m是边数。接下来m行,描述边的关系,每行3个整数:(i,j),length,表示结点i到结点j的长度是length。
当n=0时,表示输入结束。
输出
对每个测试例,输出最短路径长度所经历的结点,最短的长度。
#define NUM 100
int n; //图G的顶点数量
int m; //图G的边数
int a[NUM][NUM]; //图G的邻接矩阵
int x[NUM]; //当前解
int bestx[NUM]; //当前最优解向量
int cc; //当前费用
int bestc; //当前最优值
int NoEdge = -1; //无边标记
//形参t是回溯的深度,从2开始。根结点为第1层。城市编号从1开始.从第1个城市出发
void Backtrack(int t){
//到达叶子结点的父结点。旅行路径上的倒数第二个城市。最后一个城市是出发点
if(t==n) {
if(a[x[n-1]][x[n]]!= NoEdge && a[x[n]][1]!= NoEdge &&
(cc + a[x[n-1]][x[n]]+a[x[n]][1]<bestc||bestc== NoEdge))
{
for(int i=1; i<=n; i++)
bestx[i] = x[i];
bestc = cc + a[x[n-1]][x[n]] + a[x[n]][1];
}
return;
}
else {
for(int i=t; i<=n; i++)
{
if(a[x[t-1]][x[i]]!= NoEdge &&
(cc + a[x[t-1]][x[i]]< bestc||bestc == NoEdge))
{
swap(x[t],x[i]); // 先交换。此时,X[t]的值发变化。
cc += a[x[t-1]][x[t]]; //再计算。不能交换顺序。
Backtrack(t+1); // 如果要改变顺序,应该为cc += a[x[t-1]][x[i]]。
cc -= a[x[t-1]][x[t]];
swap(x[t],x[i]);
}
}
}
}
从t=2开始搜索。
第一次搜索到F结束(t=4)。
回溯到c后,t恢复为3,接下来要累加(2,4)这条边。
如果交换位置,会导致重新累加(2,3)这条边。
导致结果出错