旅行售货员问题
【题目】
4个城市去推销商品，已知各城市之间的路程，如右图所示。
请问他应该如何选定一条从城市1出发，经过每个城市一遍，最后回到城市1的路线，使得总的周游路程最小？并分析所设计算法的计算时间复杂度。
【分析】
x，x中的值为 1，2，3，……，n，表示该路线为由城市1依次经过城市2、3……到n后再回到城市1（当然是假设该路线存在）。如果不存在的话，我们只需改变一下这个排列的排列方式，再进行判断，所以可想而知，我们可以知道该解空间是一棵排列树。
t层时，我们需要判断一下x[t]所代表的城市是否与上一层x[t-1]所代表的城市有“路”，如果没有的话，需要改变x[t]的值，然后继续上述判断，当出现一个满足条件的x[t]后还要判断当前从1到t-1所走的路程cc加上x[t]与x[t-1]的距离是否小于当前已经记录的最优解（最优解的初始值是一个足够大的数），如果到t的距离比当前最优解还要大的话，那么再以这条路线搜索下去的话回到城市1的路程一定比当前最优解还大，所以我们没有必要对这条路线进行下一步的搜索。最后我们来确定当搜索到叶子结点的时候我们该如何处理？已知搜索到t层时，若t = n，说明已经搜索到了叶子结点，这个时候我们还需做上述所说的两个判断，如果两个判断都通过的话，说明该解比当前最优解还优，那么我们需要将该解记录下来，并记录该解的最优值。
【伪代码】
void travel(int t) {
到达第n层即搜索到叶子结点) {
城市x[t-1]可以到达城市x[t]，并且城市x[t]可以回到城市1，且此时所走的路程cc加上
与x[t]的距离和x[t]与1的距离小于当前最优值bestc) {
;
;
}
return;
}
for(int i = t; i < n; i++) {
城市x[t-1]能达到城市x[i]即这两个城市间有边，并当前所走的路程cc加上这两个城市的距离
bestc大) {
swap(x[i], x[t]);
cc;
;
cc的值;
swap(x[i], x[t]);
}
}
}
【程序】
用C++语言编写程序，代码如下：
#include<iostream>
using namespace std;
const int INF = 10000000;
int n, cc = 0, bestc = INF;
int **g;
int *x, *bestx;
void travel(int t) {
if (t == n) {
if (g[x[t - 1]][x[t]] != INF && g[x[t]][1] != INF &&
(cc + g[x[t - 1]][x[t]] + g[x[t]][1] < bestc || bestc == INF)) {
for (int i = 0; i < n + 1; i++)
bestx[i] = x[i];
bestc = cc + g[x[t - 1]][x[t]] + g[x[t]][1];
}
return;
}
for (int i = t; i < n; i++) {
if (g[x[t - 1]][x[i]] != INF && (cc + g[x[t - 1]][x[i]] < bestc
|| bestc == INF)) {
swap(x[i], x[t]);
cc += g[x[t - 1]][x[t]];
travel(t + 1);
cc -= g[x[t - 1]][x[t]];
swap(x[i], x[t]);
}
}
}
void output() {
cout << bestc << endl;
cout << bestx[1];
for (int i = 2; i < n + 1; i++)
cout << " " << bestx[i];
cout << " " << bestx[1] << endl;
}
int main() {
n = 4;
g = new int*[n + 1];
x = new int[n + 1];
bestx = new int[n + 1];
for (int i = 0; i < n + 1; i++) {
g[i] = new int[n + 1];
x[i] = i;
for (int j = 0; j < n + 1; j++)
g[i][j] = INF;
}
g[1][2] = g[2][1] = 30;
g[1][3] = g[3][1] = 6;
g[1][4] = g[4][1] = 4;
g[2][3] = g[3][2] = 5;
g[2][4] = g[4][2] = 10;
g[3][4] = g[4][3] = 20;
travel(2);
output();
return 0;
}
【结果】
先设置好城市间的距离，调用回溯方法，输出最优值（最小路程）和最优解（路线）：
该算法的时间复杂度为O(n!)。
