第六章 回溯算法

回溯算法

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

1、 问题的解空间

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

解空间的特点：
完全）二叉树.
问题的解是一棵子树（一条路）
通过深度优先搜索获得最优解

在生成解空间树时，定义以下几个相关概念：
活结点：
如果已生成一个结点而它的所有儿子结点还没有全部生成，则这个结点叫做活结点。
扩展结点：
当前正在生成其儿子结点的活结点叫扩展结点（正扩展的结点）。
死结点：
不能再进一步扩展或者其儿子结点已全部生成的结点就是死结点。
回溯从开始结点（根结点）出发，以深度优先的方式搜索整个解空间。
开始结点(根结点)成为第一个活结点，同时成为当前的扩展结点。
在当前的扩展结点，搜索向深度方向进入一个新的结点。这个新结点成为一个新的活结点，并成为当前的扩展结点。
若在当前扩展结点处不能再向深度方向移动，则当前的扩展结点成为死结点，即该活结点成为死结点。
此时回溯到最近的一个活结点处，并使得这个活结点成为当前的扩展结点。
回溯法以这样的方式递归搜索整个解空间（树），直至满足中止条件。

（1）、

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

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

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

3、子集树与排列树

有时问题是要从一个集合的所有子集中搜索一个集合，作为问题的解。或者从一个集合的排列中搜索一个排列，作为问题的解。
回溯算法可以很方便地遍历一个集合的所有子集或者所有排列。
当问题是要计算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); //对当前结点按照深度优先搜索的方式进行扩展
　　　　}
}

约束函数constraint(t)和限界函数bound(t)，称为剪枝函数。
函数update(x)是更新解向量x的。
约束函数constraint(t)，一般可以从问题描述中找到。

当所给的问题是确定n个元素满足某种性质的排列时，可以把这个解空间组织成一棵排列树。
排列树通常有n!个叶子结点。因此遍历排列树时，其计算时间复杂度是Ω(n!) 。
例如，旅行商问题就是一棵排列树。

//形参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的自然数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
}

☆☆☆6.2：装载问题

给定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

#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(); //回溯的需要
      }
   }

☆☆☆6.3：背包问题

假设当前最优值为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);
}

n皇后问题

在n×n格的棋盘上放置彼此不受攻击的n个皇后。
按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。
n皇后问题等价于在n×n格的棋盘上放置n个皇后，任何两个皇后不放在同一行或同一列或同一斜线上。
编程要求：找出一个n×n格的棋盘上放置n个皇后并使其不能互相攻击的所有方案。

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; 
}

6、旅行商问题（TSP问题）

是指一销售商从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时，表示输入结束。
输出
对每个测试例，输出最短路径长度所经历的结点，最短的长度。

数据结构：

算法实现

//形参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]);
　　　　　　}
　　　　}
　　}
}