旅行商问题的手工运算及完整代码（TSP）

驼驼学编程

已于 2022-04-13 21:13:58 修改

阅读量5.7k

点赞数 15

分类专栏：算法文章标签：算法

于 2022-04-13 19:10:48 首次发布

本文链接：https://blog.csdn.net/qq_55168827/article/details/124154389

版权

算法专栏收录该内容

14 篇文章 4 订阅

订阅专栏

1.问题描述

·某售货员要到若干城市去推销商品，已知各城市之间的路程(或旅费)。他要选定一条从驻地出发，经过每个城市一次，最后回到驻地的路线，使总的路程(或总旅费)最小。

2.解空间树是排列树

3.算法描述

·算法开始时创建一个最小堆，用于表示活结点优先队列。

·堆中每个活结点的优先级为:cc+lcost。cc为出发城市到当前城市的路程（或费用)，lcost是当前顶点(当前城市)最小出边+剩余顶点(城市)最小出边和（禁忌除外)。

·每次从优先队列中取出一个活结点成为扩展结点(s层结点)。

·当s=n-2时，扩展出的结点是排列树中某个叶子结点的父结点。如该叶结点相应一条可行回路且费用小于当前最优解bestc，则将该结点插入到优先队列中，否则舍去该结点。

·当s<n-2时，产生当前扩展结点的所有儿子结点。计算可行儿子结点的优先级cc+lcost及相关信息。当cc+lcost<bestc时，将这个可行儿子结点插入到活结点优先队列中。

该扩展过程一直持续到优先队列中取出的活结点是一个叶子结点为止。

最小出边（禁忌除外)的解释

对于刚扩展出的顶点，其前已选的所有顶点是禁忌的（不能选）。对于未扩展出的顶点，其前已选的 (顶点1除外）的顶点是禁忌的。

4.手工运算

我们先来看一道例题：

0 14 4 10 20

14 0 7 8 7

4 5 0 7 16

11 7 9 0 2

18 7 17 4 0

第一步：找出每一行的最小值

第二步：找较短路径

从1开始向后找

（1）第一步定位1->2，具体推导如下图

第三步：比较大小

30<31<42<48

故选择路径：1->4->5->2->3->1

5.代码实现

（1）分支界限法

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
using namespace std;
const int INF=1e7;  //设置无穷大的值为10^7
const int N=100;
double g[N][N];  //景点地图邻接矩阵
int bestx[N];   //记录当前最优路径
double bestl;     //当前最优路径长度
int n,m;       //景点个数n,边数m
struct Node//定义结点,记录当前结点的解信息
{
    double cl; //当前已走过的路径长度
    int id; //景点序号
    int x[N];//记录当前路径
    Node() {}
    Node(double _cl,int _id)
    {
        cl = _cl;
        id = _id;
    }
};

//定义队列的优先级。 以cl为优先级，cl值越小，越优先
bool operator <(const Node &a, const Node &b)
{
    return a.cl>b.cl;
}

//Travelingbfs 为优先队列式分支限界法搜索
double Travelingbfs()
{
    int t; //当前处理的景点序号t
    Node livenode,newnode;//定义当前扩展结点livenode,生成新结点newnode
    priority_queue<Node> q; //创建一个优先队列,优先级为已经走过的路径长度cl,cl值越小，越优先
    newnode=Node(0,2);//创建根节点
    for(int i=1;i<=n;i++)
    {
       newnode.x[i]=i;//初时化根结点的解向量
    }
    q.push(newnode);//根结点加入优先队列
    cout<<"按优先级出队顺序："<<endl;//用于调试
    while(!q.empty())
    {
        livenode=q.top();//取出队头元素作为当前扩展结点livenode
        q.pop(); //队头元素出队
        //用于调试
        cout<<"当前结点的id值:"<<livenode.id<<"当前结点的cl值:"<<livenode.cl<<endl;
        cout<<"当前结点的解向量:";
        for(int i=1; i<=n; i++)
        {
            cout<<livenode.x[i];
        }
        cout<<endl;
        t=livenode.id;//当前处理的景点序号
        // 搜到倒数第2个结点时个景点的时候不需要往下搜索
        if(t==n)  //立即判断是否更新最优解，
            //例如当前找到一个路径(1243)，到达4号结点时，立即判断g[4][3]和g[3][1]是否有边相连，
            //如果有边则判断当前路径长度cl+g[4][3]+g[3][1]<bestl，满足则更新最优值和最优解
        {
           //说明找到了一条更好的路径，记录相关信息
           if(g[livenode.x[n-1]][livenode.x[n]]!=INF&&g[livenode.x[n]][1]!=INF)
             if(livenode.cl+g[livenode.x[n-1]][livenode.x[n]]+g[livenode.x[n]][1]<bestl)
             {
                bestl=livenode.cl+g[livenode.x[n-1]][livenode.x[n]]+g[livenode.x[n]][1];
                cout<<endl;
                cout<<"当前最优的解向量:";
                for(int i=1;i<=n;i++)
                {
                  bestx[i]=livenode.x[i];
                  cout<<bestx[i];
                }
                cout<<endl;
                cout<<endl;
              }
            continue;
        }
        //判断当前结点是否满足限界条件，如果不满足不再扩展
       if(livenode.cl>=bestl)
          continue;
        //扩展
        //没有到达叶子结点
        for(int j=t; j<=n; j++)//搜索扩展结点的所有分支
        {
            if(g[livenode.x[t-1]][livenode.x[j]]!=INF)//如果x[t-1]景点与x[j]景点有边相连
            {
                double cl=livenode.cl+g[livenode.x[t-1]][livenode.x[j]];
                if(cl<bestl)//有可能得到更短的路线
                {
                    newnode=Node(cl,t+1);
                    for(int i=1;i<=n;i++)
                    {
                      newnode.x[i]=livenode.x[i];//复制以前的解向量
                    }
                    swap(newnode.x[t], newnode.x[j]);//交换x[t]、x[j]两个元素的值
                    q.push(newnode);//新结点入队
                }
            }
        }
    }
    return bestl;//返回最优值。
}

void init()//初始化
{
    bestl=INF;
    for(int i=0; i<=n; i++)
    {
        bestx[i]=0;
    }
    for(int i=1;i<=n;i++)
       for(int j=i;j<=n;j++)
          g[i][j]=g[j][i]=INF;//表示路径不可达
}
void print()//打印路径
{
    cout<<endl;
    cout<<"最短路径:  ";
    for(int i=1;i<=n;i++)
        cout<<bestx[i]<<"--->";
    cout<<"1"<<endl;
    cout<<"最短路径长度："<<bestl;
}

int main()
{
    int u, v, w;//u,v代表城市，w代表u和v城市之间路的长度
    cout << "请输入景点数 n(结点数):";
    cin >> n;
    init();
    cout << "请输入景点之间的连线数(边数):";
    cin >> m;
    cout << "请依次输入两个景点u和v之间的距离w,格式:景点u 景点v 距离w:"<<endl;
    for(int i=1;i<=m;i++)
    {
        cin>>u>>v>>w;
        g[u][v]=g[v][u]=w;
    }
    Travelingbfs();
    print();
    return 0;
}

（2）回溯法

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int INF=1e7;
const int N=100;
int g[N][N];
int x[N];       //记录当前路径
int bestx[N];   //记录当前最优路径
int cl;         //当前路径长度
int bestl;      //当前最短路径长度
int n,m;        //城市个数n,边数m
void Traveling(int t)
{
    if(t>n)
    {    //到达叶子结点
        //推销货物的最后一个城市与住地城市有边相连并且路径长度比当前最优值小
        //说明找到了一条更好的路径，记录相关信息
        if(g[x[n]][1]!=INF && (cl+g[x[n]][1]<bestl))
        {
            for(int j=1;j<=n;j++)
               bestx[j]=x[j];
            bestl=cl+g[x[n]][1];
        }
    }
    else
    {
        //没有到达叶子结点
        for(int j=t; j<=n; j++)
        {
            //搜索扩展结点的所有分支
            //如果第t-1个城市与第t个城市有边相连并且有可能得到更短的路线
            if(g[x[t-1]][x[j]]!=INF&&(cl+g[x[t-1]][x[j]]<bestl))
            {
                //保存第t个要去的城市编号到x[t]中，进入到第t+1层
                swap(x[t], x[j]);//交换两个元素的值
                cl=cl+g[x[t-1]][x[t]];
                Traveling(t+1); //从第t+1层的扩展结点继续搜索
                //第t+1层搜索完毕，回溯到第t层
                cl=cl-g[x[t-1]][x[t]];
                swap(x[t], x[j]);
            }
        }
    }
}
void init()//初始化
{
    bestl=INF;
    cl=0;
    for(int i=1;i<=n;i++)
       for(int j=i;j<=n;j++)
          g[i][j]=g[j][i]=INF;//表示路径不可达
    for(int i=0; i<=n; i++)
    {
        x[i]=i;
        bestx[i]=0;
    }
}
void print()//打印路径
{
//    cout<<"最短路径:  ";
//    for(int i=1;i<=n; i++)
//        cout<<bestx[i]<<"--->";
//    cout<<"1"<<endl;
    cout<<bestl<<endl;
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
    int u, v, w;//u,v代表城市，w代表u和v城市之间路的长度
//    cout << "请输入景点数 n(结点数):";
    cin >> n;
    init();
//    cout << "请输入景点之间的连线数(边数):";
    cin >> m;
//    cout << "请依次输入两个景点u和v之间的距离w,格式:景点u 景点v 距离w";
    for(int i=1;i<=m;i++)
    {
        cin>>u>>v>>w;
        g[u][v]=g[v][u]=w;
    }
    Traveling(2);
    print();
    }
    return 0;
}

希望对大家的学习有所帮助。

驼驼学编程

关注

15
点赞
踩
42

收藏

觉得还不错? 一键收藏
2
评论
旅行商问题的手工运算及完整代码（TSP）

目录1.问题描述2.解空间树是排列树3.算法描述4.手工运算第一步：找出每一行的最小值第二步：找较短路径第三步：比较大小5.代码实现（1）分支界限法（2）回溯法1.问题描述·某售货员要到若干城市去推销商品，已知各城市之间的路程(或旅费)。他要选定一条从驻地出发，经过每个城市一次，最后回到驻地的路线，使总的路程(或总旅费)最小。2.解空间树是排列树3.算法描述·算法开始时创建一个最小堆，用于表示活结点优先队列。·堆中每个活...
复制链接

扫一扫