旅行商
一个旅行商由某市出发，经过所有给定的n个城市后，再
回到出发的城市。除了出发的城市外，其它城市只经过一
回。这样的回路可能有多个，求其中路径成本最小的回路。
蛮力【穷举】
【例4-4】旅行商问题——排列树
计算模型
(1) 存储 图G(V, E)。以邻接矩阵的方式存储，设计如下：
(2)计算 设起始点下标为0
生成排列树。设解空间为a，则其解空间的计算过程可描述为：
求回路代价。设sumi 是并入第i个结点的代价 ：
sumi并入第i个结点的代价= sum_i-1代入第i-1个结点的代价 + 边（i-1到i)
分支限界法：
穷举法代码：
#include<iostream>
using namespace std;
//蛮力（穷举）
//邻接矩阵
int n = 4;
int edge[4][4] = { 0,8,5,4,
8,0,7,3,
5,7,0,1,
4,3,1,0 };
int vertex[4] = { 'a','b','c','d' };
int a[] = { 0,1,2,3 };//解空间
int minvalue = 10000;//当前最小值
int path[4] = { 0 };//当前解的路径
int minpath[4] = { 0 };//最优解的路径
void showpath(int a[])
{
cout << "showpath:";
for (int i = 0; i < n; i++)
{
cout << a[i] << "\t";
}
//回到终点
cout <<a[0]<< endl;
}
void copypath(int minpath[])
{
for (int i = 0; i < n; ++i)
{
minpath[i] = a[i];
}
}
int cost()//求当前路径的权值
{
int sum = edge[0][a[0]];
int i;
for (i = 1; i < n; ++i)
{
sum += edge[a[i - 1]][a[i]];
}
sum += edge[a[i - 1]][0];//回到0
return sum;
}
//递归
void EnumTSP(int i)
{
int k, temp;
if (i == n - 1)//最后一个结点，递归出口
{
if (cost() < minvalue)//当前解的权值 < 当前最小
{
minvalue = cost();//更新最小权值
copypath(minpath);//赋值到最优解路径
}
}
else
{
for (int k = i; k < n; k++)
{
//全排列
temp = a[i]; a[i] = a[k]; a[k] = temp;
//下一层递归
EnumTSP(i + 1);
//恢复现场
temp = a[i]; a[i] = a[k]; a[k] = temp;
}
}
}
int main()
{
EnumTSP(0);//从第0层开始
showpath(minpath);
cout <<"minvalue:" << minvalue << endl;
return 0;
}回溯法代码：
#include<iostream>
#include<queue>
using namespace std;
//分支限界法
typedef struct node {
bool vis[20];
int st;//起点
int ed;//终点
int k;//走过的点数
int sumv;//走过的路径距离
int lb;//目标函数的值 下界
int path[20];//当前路径
//运算符重载
bool operator<(const node& p)
{
return lb > p.lb;
}
}node;
const int INF = 10000000; //表示无穷大
int low, up, n, used[20];
int cost[20][20] = { {4,2,6,9},{4,7,8,10}, {2,7,5,3}, {6,8,5,4}, {9,10,3,4} };
char city[20] = {'A','B','C','D','E'};
priority_queue<node>q;//优先级队列
node answer;//答案 最优解
//求上界
// 当前结点下标，第几层，当前路径长度
int get_up_digui(int v, int j, int len)
{
int minE = INF;
int pos;
if (j == n)//结束
{
return len + cost[v][1];
}
//v的邻接边中最短
for (int i = 1; i <= n; i++)//从1开始
{
//未访问
if (used[i] == 0 && minE > cost[v][i])
{
minE = cost[v][i];
pos = i;
}
}
//设为访问
used[pos] = 1;
return get_up_digui(pos, j + 1, len + minE);
}
//求上界
void get_up()//求当前上界
{
used[1] = 1;//从1开始访问
up = get_up_digui(1, 1, 0);
}
//下界
void get_low()//求当前下界
{
low = 0;
//最短两条边
for (int i = 1; i <= n; i++)
{
int temp[20];
for (int j = 1; j <= n; j++)
{
temp[j] = cost[i][j];
}
sort(temp + 1, temp + 1 + n);//从1开始
low += temp[1]+temp[2];
}
low = low / 2;
//其他顶点最短两条边
}
//结点所在分支的下界
int get_lb(node p)
{
int res = p.sumv * 2;//已遍历的城市的距离
int min1 = INF, min2 = INF, pos;
//从起点 到 最近未遍历的城市的距离
for (int i = 1; i <= n; i++)
{
if (p.vis[i] == 0 && min1 > cost[p.st][i])
{
min1 = cost[p.st][i];
pos = i;
}
}
res += min1;
//从离开结点 到最近未便利城市的距离
for (int i = 1; i <= n; i++)
{
if (p.vis[i] == 0 && min2 > cost[i][p.ed])
{
min2 = cost[i][p.ed];
pos = i;
}
}
res += min2;
//进入并离开 每个未遍历城市的最小成本
for (int i = 1; i <= n; i++)
{
if (p.vis[i] == 0)
{
int temp[n];
min1 = min2 = INF;
for (int j = 1; j <= n; j++)
{
temp[j] = cost[i][j];
}
sort(temp + 1, temp + 1 + n);
res += temp[1] + temp[2];
}
}
//向上取整
res = res % 2 == 0 ? (res / 2 ):( res / 2 + 1);
return res;
}
//求解
int solve()
{
int res = INF;//
get_up();//求当前上界
get_low();//当前下界
node s;//
s.st = 1;//起始节点
s.ed = 1;//终点
s.k = 1;//走过点数
s.sumv = 0;//
s.lb = low;//当前下界
s.path[0] = 0;//起点
//
for (int i = 0; i < n; i++)//初始化 未访问，没有路径
{
s.vis[i] = 0;
s.path[i] = 0;
}
s.vis[0] = 1;//访问第一个结点
q.push(s);//当前结点入队
node next, temp;
while (!q.empty())
{
temp = q.top();//队首元素
q.pop();//出队
//结束条件
//只剩最后一个点
if (temp.k == n - 1)
{
int pos = 0;
for (int i = 1; i <= n; i++)//从0开始
{
if (temp.vis[i] == 0)//如果路径上第i点没有被访问
{
pos = i;
break;
}
}
//结束遍历
if (pos == 0)//都被访问
{
break;//结束while循环
}
//还有pos没有访问到，那么设最后一个结点是POS
//结果 当前路径长度+当前路径终点到POS+POS到当前路径起点
int ans = temp.sumv+cost[pos][temp.st]+cost[temp.ed][pos];
//最后一个结点是POS
temp.path[n] = pos;//从结点1开始计算
//当前路径的上界是
temp.lb = ans;
//此时队首元素，也是当前最优元素
node judge = q.top();
//如果当前路径比所有分支的上界都小，找到最优解
if (ans <= judge.lb);
{
res = min(ans, res);
answer = temp;//返回答案
break;
}
else if(up>=ans)//当前答案<=上界，还是有可能从其他路径更新上界
{
up = ans;
answer = temp;
}
res = min(res, ans);//更新此时的最小值
continue;
}
//
for (int i = 1; i <= n; i++)
{
if (temp.vis[i] == 0)//当前路径还未访问该点
{
next.st = temp.st;//一样的起点
next.ed = i;//结点是i
next.k = temp.k + 1;//点数+1
next.sumv = temp.sumv + cost[temp.ed][i];//更新
for (int j = 1; j <= n; j++)
{
next.vis[j] = temp.vis[j];
next.path[j] = temp.path[j];
}
next.vis[i] = 1;
next.path[next.k] = 1;//路径
next.lb = get_lb(next);//下界
if (next.lb <= up)//如果
{
q.push(next);
}//反之，剪枝
}
}
}
return res;
}
