旅行商问题

运用优先队列分支限界法

问题描述
旅行商问题（Traveling Salesman Problem，TSP）又译为旅行推销员问题、货郎担问题，简称为TSP问题，是最基本的路线问题，该推销员从一个城市出发，需要求得经过所有城市后，回到出发地的最小路径成本。

该问题的实质是从图论的角度来看，该问题实质是在一个带权完全无向图中，找一个权值最小的哈密顿回路。

解决方法
分支限界法：利用贪心方法求得上界，，优先队列式分支限界法用优先队列存储活结点表

算法分析
-对于TSP（旅行商问题），我们需要利用上界和下界来对BFS（解空间树）进行剪枝，通过不断更新上界和下界，尽可能的排除不符合需求的child（子树），以实现剪枝。最终，当上限和下限等同时，我们可以获得最优解，以解决TSP问题

解题步骤
定义队列的优先级。 以zl为优先级，zl值越小，越优先
计算下界（即每个景点最小出边权值之和）
利用优先队列分支限界法，不断更新上界和路径和，如果大于上界就不加入队列，否则加入队列求出最优解。

部分代码如下：

#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <queue>
#include<time.h>
using namespace std;
const int INF=1e7;  //设置无穷大的值为107
const int N=100;
double g[N][N];  //旅行地图邻接矩阵战争         
double minout[N]; //记录每个城市的最少出边
double minsum;    //记录所有城市的最少出边之和
int bestx[N];   //记录当前最优路径
double bestl;     //当前最优路径长度
int n,m;       //城市个数n,边数m
struct Node//定义结点,记录当前结点的解信息
{
    double cl; //当前已走过的路径长度
    double rl; //剩余路径长度的下界
    double zl; //当前路径长度的下界zl=rl+cl
    int id; //城市序号
    int x[N];//记录当前解向量
    Node() {}
    Node(double _cl,double _rl,double _zl,int _id)
    {
        cl = _cl;
        rl = _rl;
        zl = _zl;
        id = _id;
    }
};

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

bool Bound()//计算下界（即每个城市最小出边权值之和）
{
    for(int i=1;i<=n;i++)
    {
       double minl=INF;//初时化城市点出边最小值
       for(int j=1;j<=n;j++)//找每个城市的最小出边
         if(g[i][j]!=INF&&g[i][j]<minl)
            minl=g[i][j];
       if(minl==INF)
          return false;//表示无回路
       minout[i]=minl;//记录每个城市的最少出边
       cout<<"第"<<i<<"个城市的最少出边:"<<minout[i]<<" "<<endl;
       minsum+=minl;//记录所有景点的最少出边之和
    }
    cout<<"每个城市的最少出边之和:""minsum= "<<minsum<<endl;
    return true;
}

//Travelingbfsopt 为优化的优先队列式分支限界法
double Travelingbfsopt()
{
    if(!Bound())
        return -1;//表示无回路
    Node livenode,newnode;//定义当前扩展结点livenode,生成新结点newnode
    priority_queue<Node> q; //创建一个优先队列,优先级为当前路径长度的下界zl=rl+cl,zl值越小，越优先
    newnode=Node(0,minsum,minsum,2);//创建根节点
    for(int i=1;i<=n;i++)
    {
       newnode.x[i]=i;//初时化根结点的解向量
    }
    q.push(newnode);//根结点加入优先队列
    while(!q.empty())
    {
        livenode=q.top();//取出队头元素作为当前扩展结点livenode
        q.pop(); //队头元素出队
        //cout<<"当前结点的id值:"<<livenode.id<<"当前结点的zl值:"<<livenode.zl<<endl;
        //cout<<"当前结点的解向量:";
        /*for(int i=1; i<=n; i++)
        {
            cout<<livenode.x[i];
        }*/
        //cout<<endl;
        int 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]];
                double rl=livenode.rl-minout[livenode.x[j]];
                double zl=cl+rl;
                if(zl<bestl)//有可能得到更短的路线
                {
                    newnode=Node(cl,rl,zl,t+1);
                    for(int i=1;i<=n;i++)
                    {
                      newnode.x[i]=livenode.x[i];//复制以前的解向量
                    }
                    swap(newnode.x[t], newnode.x[j]);//交换两个元素的值
                    q.push(newnode);//新结点入队
                }
            }
        }
    }
    return bestl;//返回最优值。
}

void init()//初始化
{
    bestl=INF;
    minsum=0;
    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 start=clock();

    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;
    }
    Travelingbfsopt();
    print();
    int end=clock();
    printf("花费时间为：%dms\n",end-start);
    return 0;
}

总结
这是我们的一次小组作业，大家相互配合，分工协作，共同完成此个课程设计，旅行商问题是分支限界法，求最优解，具有方向性，能尽快激活限界条件，八皇后问题回溯法，找到所有可行解数量，具有系统性
回溯法
深度优先搜索
搜索过程中动态产生问题的解空间
活结点的所有可行子结点被遍历后才被从栈中弹出
找出满足约束条件的所有解
分支限界法
广度优先或最小耗费优先搜索
队列、优先队列
每个结点只有一次成为活结点的机会
找出满足约束条件的一个解或特定意义下的最优解
————————————————
版权声明：本文为CSDN博主「m0_53233211」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_53233211/article/details/118178240