0031算法笔记——【回溯法】旅行员售货问题和圆排列问题
1、旅行员售货问题
问题描述
某售货员要到若干城市去推销商品，已知各城市之间的路程（旅费），他要选定一条从驻地出发，经过每个城市一遍，最后回到驻地的路线，使总的路程（总旅费）最小。
问题分析
旅行售货员问题的解空间是一棵排列树。对于排列树的回溯法与生成1,2,……n的所有排列的递归算法Perm类似。开始时x=[1,2,……n],则相应的排列树有x[1:n]的所有排列构成。
在递归算法Backtrack中，当i=n时，当前扩展节点是排列树的叶节点的父节点。此时算法检测图G是否存在一条从顶点x[n-1]到顶点x[n]的边和一条从顶点x[n]到顶点1的边。如果这两条边都存在，则找到一条旅行员售货回路。此时，算法还需要判断这条回路的费用是否优于已找到的当前最优回流的费用bestc。如果是，则必须更新当前最优值bestc和当前最优解bestx。
当i
算法具体代码如下：
//5d9 旅行员售货问题 回溯法求解
#include "stdafx.h"
#include
#include
using namespace std;
ifstream fin("5d9.txt");
const int N = 4;//图的顶点数
template
class Traveling
{
template
friend Type TSP(Type **a, int n);
private:
void Backtrack(int i);
int n, // 图G的顶点数
*x, // 当前解
*bestx; // 当前最优解
Type **a, // 图G的领接矩阵
cc, // 当前费用
bestc; // 当前最优值
int NoEdge; // 无边标记
};
template
inline void Swap(Type &a, Type &b);
template
Type TSP(Type **a, int n);
int main()
{
cout<<"图的顶点个数 n="<>a[i][j];
cout<
void Traveling::Backtrack(int i)
{
if (i == n)
{
if (a[x[n-1]][x[n]] != 0 && a[x[n]][1] != 0 &&
(cc + a[x[n-1]][x[n]] + a[x[n]][1] < bestc || bestc == 0))
{
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]] != 0 && (cc + a[x[i-1]][x[i]] < bestc || bestc == 0))
{
// 搜索子树
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]);
}
}
}
}
template
Type TSP(Type **a, int n)
{
Traveling Y;
Y.n=n;
Y.x=new int[n+1];
Y.bestx=new int[n+1];
for(int i=1;i<=n;i++)
{
Y.x[i]=i;
}
Y.a=a;
Y.cc=0;
Y.bestc=0;
Y.NoEdge=0;
Y.Backtrack(2);
cout<<"最短回路为："< ";
}
cout<
inline void Swap(Type &a, Type &b)
{
Type temp=a;
a=b;
b=temp;
} 算法backtrack在最坏情况下可能需要更新当前最优解O((n-1)!)次，每次更新bestx需计算时间O(n)，从而整个算法的计算时间复杂性为O(n!)。
程序运行结果如图：
2、圆排列问题
问题描述
给定n个大小不等的圆c1,c2,…,cn，现要将这n个圆排进一个矩形框中，且要求各圆与矩形框的底边相切。圆排列问题要求从n个圆的所有排列中找出有最小长度的圆排列。例如，当n=3，且所给的3个圆的半径分别为1，1，2时，这3个圆的最小长度的圆排列如图所示。其最小长度为
。
问题分析
圆排列问题的解空间是一棵排列树。按照回溯法搜索排列树的算法框架，设开始时a=[r1,r2,……rn]是所给的n个元的半径，则相应的排列树由a[1:n]的所有排列构成。
解圆排列问题的回溯算法中，CirclePerm(n,a)返回找到的最小的圆排列长度。初始时，数组a是输入的n个圆的半径，计算结束后返回相应于最优解的圆排列。center计算圆在当前圆排列中的横坐标，由x^2 = sqrt((r1+r2)^2-(r1-r2)^2)推导出x = 2*sqrt(r1*r2)。Compoute计算当前圆排列的长度。变量min记录当前最小圆排列长度。数组r表示当前圆排列。数组x则记录当前圆排列中各圆的圆心横坐标。
在递归算法Backtrack中，当i>n时，算法搜索至叶节点，得到新的圆排列方案。此时算法调用Compute计算当前圆排列的长度，适时更新当前最优值。
当i
算法具体代码如下：
//圆排列问题 回溯法求解
#include "stdafx.h"
#include
#include
using namespace std;
float CirclePerm(int n,float *a);
template
inline void Swap(Type &a, Type &b);
int main()
{
float *a = new float[4];
a[1] = 1,a[2] = 1,a[3] = 2;
cout<<"圆排列中各圆的半径分别为："<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]high)
{
high=x[i]+r[i];
}
}
if (high-lown)
{
Compute();
}
else
{
for (int j = t; j <= n; j++)
{
Swap(r[t], r[j]);
float centerx=Center(t);
if (centerx+r[t]+r[1]
inline void Swap(Type &a, Type &b)
{
Type temp=a;
a=b;
b=temp;
} 上述算法尚有许多改进的余地。例如，像1,2,…,n-1,n和n,n-1, …,2,1这种互为镜像的排列具有相同的圆排列长度，只计算一个就够了，可减少约一半的计算量。另一方面，如果所给的n个圆中有k个圆有相同的半径，则这k个圆产生的k!个完全相同的圆排列，只计算一个就够了。
程序运行结果为：
