货郎问题解决

题目：货郎问题。有一个推销员，要到n个城市推销商品，要找出一个包含所有n个城市的具有最短路程的环路。（最后回到出发的城市）。

基本思想

货郎问题采用回溯法求解，在求解的过程中采用排列树、深度优先搜索方法。
回溯法基本思想：
（1）针对具体问题，定义问题的解空间。
（2）确定易于搜索的解空间结构（数据结构的选择）。
（3）以深度优先搜索的方式搜索解空间。
（4）在搜索过程中，可以使用剪枝函数等来优化算法。（剪枝函数：用约束函数和限界函数剪去得不到最优解的子树，统称为剪枝函数。）

基本用例

给定四个城市，其距离构成无向图如下图所示：

（1）代价函数：设顶点出发的最短边长度为，为选定巡回路线中第段的长度，代价函数公式为。公式的第一项表示为已经走过的路长，第二项表示从第k个城市到第k+1个城市的最小边长，最后一项表示后续没有选入城市的最短边长。
（2）界：当前得到的最短巡回路线长度。假设部分路线为，代价函数值，公式前两项9+13为走过的路径长度，第3项为从结点2出发的最短边长，第4项为从结点4出发的最短边长。
这个用例构成的搜索树如下图：

深度优先遍历该树，得到的结果如下：
第一个界: <1,2,3,4>，长度为 29。
第二个界: <1,2,4,3>，长度为 23。
结点 <1,3,2>: 代价函数值 26>23，所以不再搜索, 返回<1,3>,从右子树继续向下搜索。
结点<1,3,4>，代价函数值9+7+2+2=20, 继续向下搜索，得到可行解<1,3,4,2>，得出长度为 23.
回溯到结点<1>，沿<1,4>继续向下搜索，最终得出最优解<1,2,4,3>或<1,3,4,2>，长度23。

实现代码

#include<iostream>
using namespace std;
/*回溯法求解TSP问题，采用排列树、深度优选搜索的方法
变量：
1.城市个数n
2.城市之间的距离value[][]
3.城市走过的路程cl
4.最短路径bestx[]
5.城市编号数组x[]
步骤：
*/
#define MAXLENGTH 10
//城市个数
int n;
//城市之间的距离
int value[MAXLENGTH][MAXLENGTH];
//城市编号
int citys[MAXLENGTH];
//最优路径
int bestx[MAXLENGTH];
int maybex[MAXLENGTH];
//经过的路径
int cl = 0;
//最优路径长度
int bestl = 999;
int maybel = 999;

//修正函数原型声明
void Modify();
//Tsp函数原型声明
void Tsp(int n);
int main(){
	//计数使用
	int i, j;
	printf("请输入城市个数:");
	scanf("%d", &n);
	printf("请输入城市代价矩阵:\n");
	for ( i = 1; i <= n; i++)
	{
		for ( j = 1; j <= n; j++)
		{
			scanf("%d", &value[i][j]);
		}
	}

	Modify();

	//初始化城市编号，最优路径矩阵
	for ( i = 1; i <= n; i++)
	{
		citys[i] = i;
		bestx[i] = 0;
	}

	Tsp(2);

	//进行结果输出
	printf("最优路线为:\n");
	for ( i = 1; i <= n; i++)
	{
		printf("%4d", bestx[i]);
	}
	printf("%4d\n", bestx[1]);
	printf("最短路径长度为:%d\n", bestl);
	getchar();
	return 0;
}

//修正函数，将对角线数据置为0
void Modify(){
	for (int i = 1; i <= n; i++)
	{
		value[i][i] = -1;
	}
}

//交换函数
void swap(int &a, int &b){
	int temp;
	temp = a;
	a = b;
	b = temp;
}
//定义回溯法求TSP问题
void Tsp(int t){
	//用于计数
	int j;
	//到达叶子节点
	if (t>n)
	{
		if (value[n][1] != -1){
			//记录所经过的路径
			printf("可能的路径为:");
			for ( j = 1; j <= n; j++)
			{
				maybex[j] = citys[j];
				printf("%4d", maybex[j]);
			}
			printf("长度:%d\n", cl + value[citys[n]][1]);
		}
		if (value[citys[n]][1] != -1 && (cl + value[citys[n]][1])<bestl){
			//记录所经过的路径
			for (j = 1; j <= n; j++)
			{
				bestx[j] = citys[j];
			}
			bestl = cl + value[citys[n]][1];
		}
	}
	else{//还没有到达叶子节点
		//搜索扩展节点的左右分支，即所有与当前城市所在的邻近城市
		for ( j = t; j <= n ; j++)
		{
			//若果第t-1个城市与第t个城市之间有路径且可以得到更短的路线
			if (value[citys[t - 1]][citys[j]] != -1 && (cl + value[citys[t - 1]][citys[j]]) < bestl){
				//交换位置
				swap(citys[t], citys[j]);
				//为长度赋值
				cl += value[citys[t - 1]][citys[t]];
				//进行深度遍历
				Tsp(t + 1);
				//恢复原状
				cl -= value[citys[t - 1]][citys[t]];
				swap(citys[t], citys[j]);
			}
		}
	}
}

运行结果