【算法设计与分析】回溯backtrace | 复习笔记

最新推荐文章于 2023-06-15 20:22:22 发布

柔水终成雕刀╮(￣▽￣"")╭

最新推荐文章于 2023-06-15 20:22:22 发布

阅读量216

点赞数

分类专栏：算法设计与分析复习笔记文章标签：算法

本文链接：https://blog.csdn.net/m0_46201214/article/details/112392818

版权

复习笔记同时被 2 个专栏收录

35 篇文章 2 订阅

订阅专栏

算法设计与分析

4 篇文章 0 订阅

订阅专栏

在这里插入图片描述

文章目录

回溯的深度优先搜索策略

有许多问题，当需要找出它的解集或者要求回答什么解是满足某些约束条件的最佳解时，往往要使用回溯法
回溯法的基本做法是搜索，或是一种组织得井井有条的，能避免不必要搜索的穷举式搜索法。这种方法适用于解一些组合数相当大的问题。
回溯法在问题的解空间树中，按深度优先策略，从根结点出发搜索解空间树。算法搜索至解空间树的任意一点时，先判断该结点是否包含问题的解。如果肯定不包含，则跳过对该结点为根的子树的搜索，逐层向其祖先结点回溯；否则，进入该子树，继续按深度优先策略搜索

问题的解空间：

问题的解向量：回溯法希望一个问题的解能够表示成一个n元式(x₁, x₂, …, x_n)的形式。
显约束：对分量 x_i 的取值限定
隐约束：为满足问题的解而对不同分量之间施加的约束
解空间：对于问题的一个实例，解向量满足显式约束条件的所有多元组，构成了该实例的一个解空间
注意：同一个问题可以有多种表示，有些表示方法更简单，所需表示的状态空间更小（存储量少，搜索方法简单）。

生成问题状态的基本方法

扩展结点:一个正在产生儿子的结点称为扩展结点
活结点:一个自身已生成但其儿子还没有全部生成的节点称做活结点
死结点:一个所有儿子已经产生的结点称做死结点
深度优先的问题状态生成法：如果对一个扩展结点R，一旦产生了它的一个儿子C，就把C当做新的扩展结点。在完成对子树C（以C为根的子树）的穷尽搜索之后，将R重新变成扩展结点，继续生成R的下一个儿子（如果存在）
宽度优先的问题状态生成法：在一个扩展结点变成死结点之前，它一直是扩展结点
回溯法：为了避免生成那些不可能产生最佳解的问题状态，要不断地利用限界函数(bounding function)来处死那些实际上不可能产生所需解的活结点，以减少问题的计算量。具有限界函数的深度优先生成法称为回溯法

回溯法的基本思想

针对所给问题，定义问题的解空间；
确定易于搜索的解空间结构；
以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。
常用剪枝函数：用约束函数在扩展结点处剪去不满足约束的子树；用限界函数剪去得不到最优解的子树。
用回溯法解题的一个显著特征是在搜索过程中动态产生问题的解空间。在任何时刻，算法只保存从根结点到当前扩展结点的路径。如果解空间树中从根结点到叶结点的最长路径的长度为h(n)，则回溯法所需的计算空间通常为O(h(n))。而显式地存储整个解空间则需要O(2^h(n))或O(h(n)!)内存空间。

回溯法解题的算法框架

递归回溯

回溯法对解空间作深度优先搜索，因此，在一般情况下用递归方法实现回溯法。

void backtrack (int t){//t为递归深度，即当前扩展节点在解空间树中的深度；
	if (t > n) //n用来控制递归深度
		output(x);//算法已搜索至叶结点
	else{
		for (int i = f(n,t); i <= g(n,t); i++){//f(n,t)、g(n,t)分别表示在当前扩展节点处未搜索过的子树的起始编号和终止编号
			x[t] = h(i);//h(i)表示在当前扩展结点处x[t]的第i个可选值
			if (constraint(t) && bound(t))//constraint(t)和bound(t))分别是当前扩展结点处的约束函数和限界函数
			//constraint(t)返回true表示在当前扩展结点处x[1:t]取值满足问题的约束条件，为false表示不满足约束条件，可剪去相应的子树。
			//Bound返回true说明在x[1:t]取值未使目标函数越界，还可以继续由backtrack(t+1) 继续对其子树进一步搜索。Bound返回true ，说明已越界，可以剪去其子树
				backtrack(t+1);
		}
	}
}

迭代回溯

采用树的非递归深度优先遍历算法，可将回溯法表示为一个非递归迭代过程。

void iterativeBacktrack (){
	int t=1;
	while (t > 0) {
		if ( f(n,t) <= g(n,t))
			for (int i = f(n,t); i <= g(n,t); i++) {
				x[t] = h(i);
				if (constraint(t) && bound(t)) {
					if (solution(t)) 
						output(x);
					else t++;
				}
			}
		else t--;
	}
}

子集树与排列树

在这里插入图片描述

void backtrack (int t){
	if (t > n) 
		output(x);
	else
		for (int i = 0; i <= 1; 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个集装箱要装上2艘载重量分别为 c1 和 c2 的轮船，其中集装箱 i 的重量为 w_i ，且 $\Sigma$ ⁿ_i=1w_i <= c₁ + c₂
装载问题要求确定是否有一个合理的装载方案可将这个集装箱装上这2艘轮船。如果有，找出一种装载方案。

容易证明，如果一个给定装载问题有解，则采用下面的策略可得到最优装载方案。

首先将第一艘轮船尽可能装满；
将剩余的集装箱装上第二艘轮船。

将第一艘轮船尽可能装满等价于选取全体集装箱的一个子集，使该子集中集装箱重量之和最接近。由此可知，装载问题等价于以下特殊的0-1背包问题。
在这里插入图片描述

解空间：子集树
可行性约束函数(选择当前元素)： $\Sigma$ ⁿ_i=1w_i <= c₁
上界函数(不选择当前元素)：当前载重量cw + 剩余集装箱的重量r <= 当前最优载重量 bestw

template <class Type>
class Loading{
	friend Type MaxLoading(Type [], Type, int);
	private:
		void Backtrack(int i);
		int n;
		Type * w, c, cw, bestw, r;
};
Type MaxLoading(Type w[],Type c,int n) {
	Loading<Type> X; //初始化
	X.w = w; //wi: 第i个集装箱重量
	X.c = c; //c：最大承重容量
	X.n = n; //当前集装箱个数
	X.bestw = 0; //bestw：当前最优装载重量
	X.cw = 0; //cw：当前载重量
	X.r = 0; //初始化r，r为剩余（当前为考察过的）集装箱重量
	for(int i = 1; i <= n; i++) //计算总共的剩余（当前为考察过的）集装箱重量
		X.r += w[i];
	X.Backtrack(1);
	return X.bestw;
}
//深度优先
void Loading<Type>::Backtrack(int i) { //搜索第i层结点
	if(i > n) { //一个新的可行解
		if(cw > bestw){ //更新最优解
			bestw = cw;
			bestx = x;
		}
		return;
	}
	r -= w[i]; //计算剩余(未考察)的集装箱的重量，减去当前考察过的对象的重量
	if(cw + w[i] <= c){
		cw += w[i];
		x[i] = 1;
		Backtrack(i + 1);//进入下一层，搜索左子树
		cw -= w[i];
	}
	if (cw + r > bestw) {
		x[i] = 0; // 搜索右子树
		backtrack(i + 1); 
	}
	r += w[i]; //递归回退返回上一层时，记得修改r的当前值，如果得不到最优解，再取消当前考察的集装箱，标记为未选，因此剩余容量要再加上当前集装箱重量
}

批处理作业调度

给定 n 个作业的集合 { J₁, J₂, …, J_n }。每个作业必须先由机器1处理，然后由机器2处理。作业 J_i 需要机器 j 的处理时间为 t_ji。对于一个确定的作业调度，设 F_ji 是作业 i 在机器 j 上完成处理的时间。所有作业在机器2上完成处理的时间和称为该作业调度的完成时间和。批处理作业调度问题要求对于给定的n个作业，制定最佳作业调度方案，使其 t_ji 完成时间和达到最小。

这里注意一下批处理作业调度和流水作业调度的区别
流水作业调度的最终目标是要求完成所有任务的时间最短，所以把最后一个任务的完成时间作为标准
而批处理作业调度的目的是要让每一个作业都尽快得到处理，所以要把每个作业的完成时间之和作为标准。
两者看上去相似，但实际上还是有区别的，可能在某些情况下调度是顺序是一样的。批处理作业采用回溯法，一定能够得到最优解，因为你搜索的是整个解空间；流水作业调度采用动态规划法，同样能够等到最优解
区别摘自流水作业与批处理作业调度

以1,2,3为例:
作业1在机器1上完成的时间为2,在机器2上完成的时间为3
作业2在机器1上完成的时间为5,在机器2上完成的时间为6
作业3在机器1上完成的时间为7,在机器2上完成的时间为10
3+6+10=19，所以是19
这3个作业的6种可能的调度方案是1,2,3；1,3,2；2,1,3；2,3,1；3,1,2；3,2,1；它们所相应的完成时间和分别是19，18，20，21，19，19。易见，最佳调度方案是1,3,2，其完成时间和为18

解空间：排列树

class Flowshop {
	friend Flow(int**, int, int []);
	private:
		void Backtrack(int i);
		int **M, //各作业所需的处理时间，是一个二维数组
		*x, //当前作业调度，是一个一维数组，记录直到当前的作业排序
		*bestx, //当前最优作业调度，一维数组，记录最优的作业排序
		*f2, //机器2完成处理时间，一维数组，记录每个作业对应的M2完成时间，用来回溯
		f1, //机器1完成处理时间
		f, //完成时间和
		bestf, //当前最优值
		n; //作业数
};
void Flowshop::Backtrack(int i){
	if (i > n) {//已完成所有作业，更新结果
		for (int j = 1; j <= n; j++)
			bestx[j] = x[j];
			bestf = f;
	}
	else //i-1层
		for (int j = i; j <= n; j++) {
			f1 += M[x[j]][1]; //作业j在M1上的加工时间
			f2[i] = ((f2[i - 1] > f1) ? f2[i - 1] : f1) + M[x[j]][2];//比较第i个作业在M1上的结束时间和M2上一个作业完成的结束时间，作为第i个作业在M2上的开始时间
			f += f2[i]; //作业1…j完成的加工时间之和
			if (f < bestf) {//在i层找到更优的作业调度
				Swap(x[i], x[j]);
				Backtrack(i + 1);
				Swap(x[i], x[j]);
			}
			f1 -= M[x[j]][1];
			f -= f2[i];
		}
}

符号三角形问题

下图是由14个“+”和14个“-”组成的符号三角形。2个同号下面都是“+”，2个异号下面都是“-”。

在一般情况下，符号三角形的第一行有n个符号。符号三角形问题要求对于给定的n，计算有多少个不同的符号三角形，使其所含的“+”和“-”的个数相同。

解向量：用n元组x[1:n]表示符号三角形的第一行
可行性约束函数：当前符号三角形所包含的“+”个数与“-”个数均不超过n*(n+1)/4
无解的判断：n*(n+1)/2为奇数

void Triangle::Backtrack(int t){//并不按照行的方式，而是一斜杠一斜杠来的，t就是斜杠数
	if ((count > half) || (t * (t - 1) / 2 - count > half)) //如果此时“+”已经超过一半或“-”超过一半，则直接返回
		return;
  	if (t > n) //找到一个可行解
  		sum++;
	else
		for (int i = 0; i < 2; i++){//以0表示-，以1表示+
			p[1][t] = i;
			count += i;
			for (int j = 2; j <= t; j++){
				p[j][t-j+1] = p[j-1][t-j+1]^p[j-1][t-j+2];
				count += p[j][t-j+1];
			}
			Backtrack(t + 1);//进入下一斜杠
			for (int j = 2; j <= t; j++)//返回上一斜杠的情况
				count -= p[j][t-j+1];
			count -= i;
		}
}

n后问题

在n×n格的棋盘上放置彼此不受攻击的n个皇后。按照国际象棋的规则，皇后可以攻击与之处在同一行或同一列或同一斜线上的棋子。n后问题等价于在n×n格的棋盘上放置n个皇后，任何2个皇后不放在同一行或同一列或同一斜线上。

设第 i 行的皇后，放置在 X_i 列上。则 n 后问题就是发现所有可能的序列（x₁, x₂, … , x_n)。要使得 n 个皇后放置均不在同一行、同一列，同一个对角线上，则只需要满足如下条件：

对任意不同的 i，j，应满足x_i ≠ x_j不在同一行、同一列
在正对角线（斜率为1）： i + x_i = j + x_j -> i - j = x_j - x_i
在反对角线（斜率为-1）：i - x_i = j - x_j -> i - j = x_i - x_j
同一正、反对角线：| i - j | = | x_i - x_j |

解向量：(x₁, x₂, … , x_n)
显约束：x_i = 1,2, … ,n
隐约束：
1. 不同列：x_i ≠ x_j
2. 不处于同一正、反对角线：| i - j | ≠ | x_i - x_j|

bool Queen::Place(int k){
	for (int j = 1; j < k; j++)
		if ((abs(k-j) == abs(x[j]-x[k])) || (x[j] == x[k]))//不处在
			return false;
	return true;
}
//递归回溯
void Queen::Backtrack(int t){
	if (t > n) 
		sum++; //输出结果x[0:n]
	else
		for (int i = 1; i <= n; i++){
			x[t] = i;
			if (Place(t)) 
				Backtrack(t + 1);
		}
}
public static long Queen::nQueen(int nn){
	n = nn;
	sum = 0;
	x = new int[n+1];
	for (i = 0; i <= n; i++) 
		x[i] = 0;
	backtrack(1);
	return sum++;
}
//long sum, int n, int []x为静态成员变量
// 迭代回溯
private static void nQueen:backtrack(){
	// k表示当前第t层，x[k]表示第t层的值
	x[1] = 0;
	int k = 1;
	while (k > 0){
		x[k] += 1;
		while ( (x[k] <= n && !(Place(k) ) 		
			x[k] += 1;//一直找到xk处可以放的第一个位置再跳出循环
		if (x[k] <= n){//可以放置在k位置
			if (k == n){ //最后一个皇后
				sum++;
				cout<<x;//得到一个解，输出x[1:n]
			}
			else{
				k++; 
				x[k] = 0; //放置下一个（层）皇后，深度优先
			}
		}
		else
			k--; //不可以放置，回退到上一层皇后位置
	}
}

0-1背包问题

解空间：子集树
可行性约束函数： $\Sigma$ ⁿ_i=1w_ix_i<= c
上界函数：

double capacity; //背包容量
int n; //物品数
double []w; //物品重量数组
double []v; //物品价值数组
double cw; //当前重量
double cp; //当前价值
double bestvalue; //当前最优价值
Bound（）//计算后半段最大价值的时候，使用的是一个贪心算法。尽管切割的情况是不被同意的，可是能够用这个结果来进行估算
private static double Bound(int i){// 计算上界
	double cleft = capacity - cw; // 剩余容量
	double value = cv;
	// 以物品单位重量价值递减序装入物品
	while (i <= n && w[i] <= cleft) {
		cleft -= w[i];
		value += v[i];
		i++;
	}
	// 装满背包
	if (i <= n) 
		value += v[i] / w[i] * cleft;
	return value;
}
//递归回溯 
private static double Backtrack(int i) { 
	if （i > n） {//到达叶结点 
		bestvalue = cv; 
		return; 
	}
	//搜素子树 
	if (cw + w[i] <= capacity) {//进入左子树 
		cw += w[i]; //当前重量增加
		cv += v[i]; //当前价值增加
		Backtrack(i + 1); 
		cw -= w[i]; //回退原来的重量
		cv -= v[i]; //回退原来的价值
	}
	if (Bound(i + 1) > bestvalue) //跳过i可以获得更大的价值
		Backtrack(i + 1); //进入右子树 
}

最大团问题

给定无向图G=(V，E)。如果U $\subseteq$ V，且对任意u，v $\in$ U有(u，v) $\in$ E，则称U是G的完全子图。G的完全子图U是G的团当且仅当U不包含在G的更大的完全子图中。G的最大团是指G中所含顶点数最多的团。如果U $\subseteq$ V且对任意u，v $\in$ U有(u，v) $\in$ E，则称U是G的空子图。G的空子图U是G的独立集当且仅当U不包含在G的更大的空子图中。G的最大独立集是G中所含顶点数最多的独立集。对于任一无向图G=(V，E)其补图G=(V1，E1)定义为：V1=V，且(u，v) $\in$ E1当且仅当(u，v) $\notin$ E。

解空间：子集树
可行性约束函数：顶点i到已选入的顶点集中每一个顶点都有边相连。
上界函数：有足够多的可选择顶点使得算法有可能在右子树中找到更大的团。

int x[n];// 当前解；cn当前顶点数
int bestn;//当前最大顶点数 bestx当前最优解
bool a[n][n];//原图中的顶点与边的连接关系
int n; // 为图的顶点数
void Clique::Backtrack(int i){//计算最大团
	if (i > n) {// 到达叶结点
		for (int j = 1; j <= n; j++) //更新	
			bestx[j] = x[j];
		bestn = cn; 
		return;
	}
	// 检查顶点 i 与当前团的连接
	int OK = 1;
	for (int j = 1; j < i; j++)
		if (x[j] != 0 && a[i][j] ) {//j是最大团中的节点，且 i与j不相连
			OK = 0; 
			break;
		}
	if (OK){//节点i满足最大团， 进入左子树
		x[i] = 1; 
		cn++;
		Backtrack(i + 1);
		x[i] = 0; 
		cn--; //恢复状态，为回溯做准备
	}
	if (cn + n - i > bestn) {// 进入右子树
		x[i] = 0;
		Backtrack(i + 1);
	}
}

复杂度分析

最大团问题的回溯算法backtrack所需的计算时间显然为O(n2n)。

进一步改进

选择合适的搜索顺序，可以使得上界函数更有效的发挥作用。例如在搜索之前可以将顶点按度从小到大排序。这在某种意义上相当于给回溯法加入了启发性。
定义S_i = { v_i, v_i+1, …, v_n}，依次求出S_n, S_n-1, …, S₁的解。从而得到一个更精确的上界函数，若cn + S_i <= max则剪枝。同时注意到：从 S_i+1 到 S_i，如果找到一个更大的团，那么 v_i 必然属于找到的团，此时有S_i = S_i+1 + 1，否则 S_i = S_i+1。因此只要max的值被更新过，就可以确定已经找到最大值，不必再往下搜索了。

图的m着色问题

给定无向连通图G和m种不同的颜色。用这些颜色为图G的各顶点着色，每个顶点着一种颜色。是否有一种着色法使G中每条边的2个顶点着不同颜色。这个问题是图的m可着色判定问题。若一个图最少需要m种颜色才能使图中每条边连接的2个顶点着不同颜色，则称这个数m为该图的色数。求一个图的色数m的问题称为图的m可着色优化问题。

解向量：(x1, x2, … , xn)表示顶点i所着颜色x[i]
可行性约束函数：顶点i与已着色的相邻顶点颜色不重复。

void Color::Backtrack(int t){
	if (t > n) {
		sum++;
		for (int i = 1; i <= n; i++)
			cout << x[i] << ' ';
		cout << endl;
	}
	else
		for (int i = 1;i <= m; i++) {
			x[t] = i;
			if (Ok(t)) 
				Backtrack(t + 1);
		}
}
bool Color::Ok(int k){// 检查颜色可用性
	for (int j = 1;j <= n; j++)
		if ( (a[k][j] == 1) && (x[j] == x[k]) ) 
			return false;
	return true;
}

复杂度分析

图m可着色问题的解空间树中内结点个数是 $\Sigma$ ^n-1_i=0mⁱ 对于每一个内结点，在最坏情况下，用ok检查当前扩展结点的每一个儿子所相应的颜色可用性需耗时O(mn)。因此，回溯法总的时间耗费是 $\Sigma$ ^n-1_i=0mⁱ (mn) = nm ( mⁿ-1 ) / ( m-1 ) = O( nmⁿ )

旅行售货员问题

旅行售货员问题(travelling salesman problem)是一类组合最优化问题，设有一个售货员从城市1出发，到城市2，3，…，n去推销货物，最后回到城市1.假定任意两个城市i，j间的距离 d_ij ( d_ij = d_ji ) 是已知的，问他应沿着什么样的路线走，才能使走过的路线最短（总旅费最小）?
旅行售货员问题就是在一个完全网络中，找出一个具有最小权的哈密顿圈，寻求旅行售货员问题的有效算法似乎是没有希望的，它属于NP完全类，一个可行的办法是首先求一个哈密顿圈，然后适当修改，以得到具较小权的另一个哈密顿圈。
意义：
旅行售货员问题有着明显的实际意义，除售货员之外，邮局里负责到各个信箱取信的邮递员；去各个分局送邮件的汽车等都会类似地遇到这个问题；还有一些问题表面上似乎与之无关，而实质上却可以归结为旅行售货员问题求解，如计算机线路问题、无中间存储的工件加工问题等。

在递归中，当i=n时，当前扩展结点是排列树的叶结点的父结点。此时算法检测图G是否存在一条从顶点x[n-1]到顶点x[n]的边和一条从顶点x[n]到顶点1的边，如果这两条边都存在，则找到一条旅行售货员的回路，此时算法再判断这条回路的费用是否优于当前已经找到的最优回路的费用bestc。
if (a[x[n-1]][x[n]] <MAX_VALUE &&
a[x[n]][1] < MAX_VALUE &&
(cc + a[x[n-1]][x[n]] + a[x[n]][1] < bestc || bestc>MAX_VALUE))
当i<n时，当前结点扩展到排列树的第i-1层，图G中存在从顶点x[i-1]到顶点x[i]的边时，x[1:i]构成图G的一条路径，且当x[1:i]的费用小于当前最优值时，算法进入排列树的第i层；否则，剪去相应的子树。用CC来记录当前路径X[1:i]的费用

template<class Type>
void Traveling<Type>::Backtrack(int i){//float a[][]为邻接矩阵，若a[i][j]为MAX_VALUE则城市i与城市j之间旅费极大
	if (i == n) {
		if (a[x[n-1]][x[n]] < MAX_VALUE && 
		  a[x[n]][1] < MAX_VALUE &&
		  (cc + a[x[n-1]][x[n]] + a[x[n]][1] < bestc || 
		  bestc > MAX_VALUE)) {
			for (int j = 1; j <= n; j++) 	
				bestx[j] = x[j];
			bestc = cc + a[x[n-1]][x[n]] + a[x[n]][1];
		}
	}
	else {
		for (int j = i; j <= n; j++)// 是否可进入x[j]子树
			if ( a[x[i - 1]][x[j]] < MAX_VALUE &&
			(cc + a[x[i - 1]][x[i]] < bestc ||
			bestc == MAX_VALUE)) {// 搜索子树
				Swap(x[i], x[j]);
				cc += a[x[i - 1]][x[i]];
				Backtrack(i + 1);
				cc -= a[x[i - 1]][x[i]];
				Swap(x[i], x[j]);
			}
	}
}

复杂度分析
算法backtrack在最坏情况下可能需要更新当前最优解O((n-1)!)次，每次更新bestx需计算时间O(n)，从而整个算法的计算时间复杂性为O(n!)。

圆排列问题

给定n个大小不等的圆c1,c2,…,cn，现要将这n个圆排进一个矩形框中，且要求各圆与矩形框的底边相切。圆排列问题要求从n个圆的所有排列中找出有最小长度的圆排列。例如，当n=3，且所给的3个圆的半径分别为1，1，2时，这3个圆的最小长度的圆排列如图所示。其最小长度为2 + 4 $\sqrt{2}$

问题分析：

圆排列问题的解空间是一棵排列树。按照回溯法搜索排列树的算法框架，设开始时a=[r1,r2,……rn]是所给的n个元的半径，则相应的排列树由a[1:n]的所有排列构成。
center计算圆在当前圆排列中的横坐标，由x² = sqrt( (r1+r2)² - (r1-r2)² )推导出x = 2* sqrt(r1*r2)。
Compute 计算当前圆排列的长度。变量lenmin记录当前最小圆排列长度。数组r存储所有圆的半径。数组x则记录当前圆排列中各圆的圆心横坐标
在递归算法Backtrack中，当i>n时，算法搜索至叶节点，得到新的圆排列方案。此时算法调用Compute计算当前圆排列的长度，适时更新当前最优值。当i<n时，当前扩展节点位于排列树的i-1层。此时算法选择下一个要排列的圆，并计算相应的下界函数

void Circle::Backtrack(int t){
	if (t > n) 
		Compute();
	else
		for (int j = t; j <= n; j++) {
			Swap(r[t], r[j]);
   			float centerx = Center(t);
			if (centerx + r[t] + r[1] < min) {//下界约束
				x[t] = centerx;
				Backtrack(t + 1);
			}
			Swap(r[t], r[j]);
		}
}
float Circle::Center(int t){// 计算当前所选择圆的圆心横坐标
	float temp = 0;
	for (int j = 1; j < t; j++) {
		float valuex = x[j] + 2.0 * sqrt( r[t] * r[j] );
		if (valuex > temp) 
			temp = valuex;
	}
	return temp;
}
void Circle::Compute(void){// 计算当前圆排列的长度
	float low = 0, high = 0;
	for (int i = 1;i <= n; i++) {
		if (x[i] - r[i] < low) 
			low = x[i] - r[i];
		if (x[i] + r[i] > high) 
			high = x[i] + r[i];
	}
	if (high - low < min) 
		min = high - low;
}

上述算法尚有许多改进的余地。例如，象1,2,…,n-1,n和n,n-1, …,2,1这种互为镜像的排列具有相同的圆排列长度，只计算一个就够了，可减少约一半的计算量。另一方面，如果所给的n个圆中有k个圆有相同的半径，则这k个圆产生的k!个完全相同的圆排列，只计算一个就够了

部分内容参考自图文并茂详尽剖析圆排列问题

连续邮资问题

假设国家发行了n种不同面值的邮票，并且规定每张信封上最多只允许贴m张邮票。连续邮资问题要求对于给定的n和m的值，给出邮票面值的最佳设计，在1张信封上可贴出从邮资1开始，增量为1的最大连续邮资区间。
例如，当n=5和m=4时，面值为( 1, 3, 11, 15, 32 )的5种邮票可以贴出邮资的最大连续邮资区间是1到70。

解向量：用n元组x[1:n]表示n种不同的邮票面值，并约定它们从小到大排列。x[1]=1是唯一的选择。
可行性约束函数：已选定x[1:i-1]，最大连续邮资区间是[1:r]，接下来x[i]的可取值范围是[x[i-1]+1:r+1]。

如何确定r的值？

计算X[1:i]的最大连续邮资区间在本算法中被频繁使用到，因此势必要找到一个高效的方法。考虑到直接递归的求解复杂度太高，我们不妨尝试计算用不超过m张面值为x[1:i]的邮票贴出邮资k所需的最少邮票数y[k]。通过y[k]可以很快推出r的值。事实上，y[k]可以通过递推在O(n)时间内解决：

for (int j = 0; j <= x[i-2] * (m-1); j++)//对上一层的邮资值数组进行更新，上限是x[i-2]*(m-1) 
	if (y[j] < m)
		for (int k = 1; k <= m - y[j]; k++)//从只使用一个x[i]到使用m-y[i]个，即使用最多的最大值，降低邮票数 
			if (y[j] + k < y[j + x[i-1] * k]) 
				y[j + x[i-1] * k] = y[j] + k;//如果前面的某一个情况加上k个x[i]，所达到邮资值使用的邮票数少于原来的邮票数则更新
while (y[r] < maxint) //向后寻找最大邮资值
	r++;

这一段老师的ppt写得并不好，详情可以看连续邮资问题

搜索结点的状态应该是已经确定的邮票面值 ( 各不相同并且总数不超过 n) 和它们能够贴出的最大连续邮资区间，以此来枚举下一个可能的邮票面值。因此，很自然地，使用原书中的标识符，数组 x 记录当前已经确定的邮票面值，整数 r 表示当前使用不超过 m 张邮票能贴出的最大连续邮资区间。对于第 i 层的结点， x[1…i] 表示当前已经有 i 个面值确定， r 表示由 x[1…i] 能贴出的最大连续区间，现在，要想把第 i 层的结点往下扩展，有两个问题需要解决：一，哪些数有可能成为下一个的邮票面值，即 x[i+1] 的取值范围是什么；二，对于一个确定的 x[i+1] ，如何更新 r 的值让它表示 x[1…i+1] 能表示的最大连续邮资区间。
第一个问题很简单， x[i+1] 的取值要和前面 i 个数各不相同，最小应该是 x[i] + 1 ，最大就是 r+1 ，否则 r+1 没有办法表示。我们现在专注第二个问题。
第二个问题自己有两种思路：一，计算出所有使用不超过 m 张 x[1…i+1] 中的面值能够贴出的邮资，然后从 r+1 开始逐个检查是否被计算出来。二，从 r+1 开始，逐个询问它是不是可以用不超过 m 张 x[1…i+1] 中的面值贴出来。
两种思路直接计算其计算量都是巨大的，需要借助动态规划的方法。模仿 0-1 背包问题，假设 S(i) 表示 x[1…i] 中不超过 m 张邮票的贴法的集合，这个集合中的元素数目是巨大的，例如，只使用 1 张邮票的贴法有 C(i+1-1,1) ＝ C(i,1)=i 种，使用 2 张邮票的贴法有 C(i+2-1,2)=C(i+1,2)=i*(i+1)/2 种，……，使用 m 张邮票的贴法有 C(i+m-1, m) 种，其中 C(n,r) 表示 n 个元素中取 r 个元素的组合数。于是， S(i) 中的元素的数目总共有 C(i+1-1, 1) + C(i+2-1,2)+ … + C(i+m-1,m) 个。 S(i) 中的每个元素就是一种合法的贴法，对应一个邮资。当前最大连续邮资区间为 1 到 r ，那么 S(i) 中每个元素的邮资是不是也在 1 到 r 之间呢？不一定，比如 {1,2,4} ，当 m=2 时，它能贴出来 8 ，但不能贴出来 7 ，这一点自己在写代码时犯了错误。总之，在搜索时，一定要保持状态的一致性，即当深度搜索到第 i 层时，一定要确保用来保存结点状态的变量中保存的一定是第 i 层的这个结点的状态。言归正传，定义 S(i) 中元素的值就是它所表示的贴法贴出来的邮资，于是，可以把 S(i) 中的元素按照它们的值的相等关系分成 k 类。第 j 类表示贴出邮资为 j 的所有的贴法集合，用 T(j) 表示， T(j) 有可能是空集，例如对于 {1,2,4},T(7) 为空集， T(8)={{4,4}} 。此时有： S( i ) = T(1) U T(2) U T(3) U … U T(k) ， U 表示两个集合的并。
现在考虑 x[i+1] 加入后对当前状态 S(i) 的影响。假设 s 是 S(i) 中的一个元素，即 s 表示一种合法的贴法， x[i+1] 对 s 能贴出的邮资的影响就是 x[i+1] 的多次重复增加了 s 能贴出的邮资。这样说是因为有两种情况不需要考虑：一，　从 s 中去掉几张邮票，把 x[i+1] 加进去，这没有意义，因为从 s 中去掉几张邮票后 s 就变成了 S(i) 中的另一个元素 t ，我们迟早会对 t 考虑 x[i+1] 的影响的。二，将 x[i+1] 加入 s ，同时再把 x[1] 也加入 s( 如果 s 中还能再贴两张邮票的话 ) ，这也没有意义，原因同一。所以， x[i+1] 对 s 的影响就是，如果 s 中贴的邮票不满 m 张，那就一直贴 x[i+1] ，直到 s 中有 m 张邮票，这个过程会产生出很多不同的邮资，它们都应该被加入到 S(i+1) 中。因为 s 属于 S(i) ，它也必定在某个 T(k) 中，而 T(k) 中能产生出最多不同邮资的是 T(k) 中用的邮票最少的那个元素。至此，原书中的解法就完全出来了：用数组 x 记录当前已经确定的邮票面值，用 r 表示当前最大的连续邮资区间，用数组 y 表示用当前的面值贴出某个邮资所需要的最少的邮票数。状态结点的转换过程已经在上面说的非常清楚了。