分支限界求解货郎担/旅行商问题

最新推荐文章于 2021-06-26 14:06:03 发布
原创 最新推荐文章于 2021-06-26 14:06:03 发布 · 7k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#matrix #vector #path #数据结构 #im #class

本文介绍了一种使用限界函数法解决货郎担问题的算法实现。该算法通过生成规约矩阵并利用优先队列来搜索最优路径，有效地降低了问题的复杂度。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 
/*  文件名：BoundleSalesMan.h   限界函数法   */
#pragma once
#include "salesman.h"
#include <vector>
#include "Node.h"
class BoundSalesMan :
     public SalesMan
{
protected:
     int SetIMatrix(int i,int k,vector<vector<int> > & im);//生成第i点的规约矩阵,并返回约数,k点为其父结点
     int Cost(vector<int> A); //获取A中保存的路径的路径长度
     int SimMatrix(vector< vector<int> > & m); //将m规约
public: 
     void Travel();
};
/*  文件名：BoundleSalesMan.cpp   限界函数法   */
#include "StdAfx.h"
#include "BoundSalesMan.h"
#include "Node.h"
#include <queue>
#include <vector>
int BoundSalesMan::SimMatrix(vector<vector<int> > & m)
//将m规约
{
     int result=0;
     int col=(int)m.size()-1;
     bool boolMax,boolZone;
     //对行进行规约
     for (int i=0;i<=col;i++)
     {
         boolMax=true,
         boolZone=false;
         for (int j=0;j<=col;j++)
         {
              boolMax=boolMax && (m[i][j]==MAXNUM); //所有都是无穷大
              boolZone=boolZone || (m[i][j]==0) ; //是否有一个是0
         }
         if ((boolMax) || (boolZone))
         //如果本行所有数据元素都是无穷大，或者有一个是0，本行已经规约
              continue;//继续下一行
         else  //否则
         {
              //从本行中找到最小的一个值，减去他，约数加上这个值
              int min=m[i][0];
              for (int k=1;k<=col;k++)
              {
                   if (min>m[i][k])
                       min=m[i][k];
              }
              for (int k=0;k<=col;k++)
              {
                   if (m[i][k]!=MAXNUM)  //如果是无穷值，则不变
                    m[i][k]-=min;
              }
              result+=min;
         }
     }   
     //对列进行规约
     for (int i=0;i<=col;i++)
     {
         boolMax=true,
         boolZone=false;
         for (int j=0;j<=col;j++)
         {
              boolMax=boolMax && (m[j][i]==MAXNUM); //所有都是无穷大
              boolZone=boolZone || (m[j][i]==0) ; //是否有一个是0
         }
         if ((boolMax) || (boolZone))
         //如果本列所有数据元素都是无穷大，或者有一个是0，本列已经规约
              continue;//继续下一列
         else  //否则
         {
              //从本列中找到最小的一个值，减去他，约数加上这个值
              int min=m[0][i];
              for (int k=1;k<=col;k++)
              {
                   if (min>m[k][i])
                       min=m[k][i];
              }
              for (int k=0;k<=col;k++)
              {
                   if (m[k][i]!=MAXNUM) //如果是无穷值，则不变
                    m[k][i]-=min;
              }
              result+=min;
         }
     }
     return result;
}
int  BoundSalesMan::SetIMatrix(int i,int k,vector<vector<int> > & im)
//生成第i点的规约矩阵
{
     int cols=im.size()-1;
     //先将k行和i列置为无穷/
     for (int j=0;j<=cols;j++)
     {
         im[k][j]=MAXNUM;  
         im[j][i]=MAXNUM;
     }
     //再将i行0列置为无穷
     im[i][0]=MAXNUM;  
     //再进行规约，记录规约值
     return SimMatrix(im);
}
 
int BoundSalesMan::Cost(vector<int> A)
//获取A中保存的路径的路径长度
{
     int i=A.size();
     int sum=matrix[0][A[0]];//先求从0到第一个点的距离
     for (unsigned int i=1;i<A.size();i++)
     {
         sum+=matrix[A[i-1]][A[i]];
     }
     sum+=matrix[A[i-1]][0];//再加上最后一个点到0点的距离
     return sum;
}
void BoundSalesMan::Travel()
{
     path.clear();
     vector<vector<int> > simpleM=matrix; //0点的规约矩阵
     int n0=SimMatrix(simpleM);
     int cols=matrix.size()-1;  
     priority_queue<Node> p;
     Node firstNode(n0,0,0,path,simpleM);
     p.push(firstNode);                    //0结点入队列
     Node node;
     while (! p.empty() && p.top().level<cols )
     {
         node=p.top();
         p.pop();
         for (int i=1;i<=cols;i++)
         {
              for (int j=0;j<node.states.size();j++)
              {
                   if (i==node.states[j]) //路径里有这个点了
                       break;
              }
              if (j<node.states.size())
                   continue; 
              //否则
              simpleM=node.m;
              int tmp=node.num;
              tmp+=simpleM[node.position][i];
              tmp+=SetIMatrix(i,node.position ,simpleM); //对第i点的矩阵进行处理                       vector<int> tmpPath=node.states;
              tmpPath.push_back(i);
              Node newNode(tmp,node.level+1,i,tmpPath,simpleM);
              p.push(newNode);
         }
     }
     path=p.top().states;
     cout<<"Bound MinValue:"<<Cost(path)<<endl;
     PrintPath();
}
 
/* 文件名：SalesMan。H  货郎担基类头文件  */
#pragma once
#include <vector>
#include <fstream>
using namespace std;
class SalesMan
{
protected:
     enum{MAXNUM=999}; //最大值设为无穷大
     vector<vector<int> >  matrix; //对应的邻接矩阵
     vector<int> path; //记录走过的最小成本路径
     int minValue;//最小路径长度
public:
     SalesMan();
     virtual ~SalesMan(){matrix.clear();path.clear();}
     void PrintMatrix(); //打印矩阵值
     void PrintPath();  //打印路径
     virtual void Travel(){}; //主要寻找路径的函数，将在子类里面实现
};
/* 文件名：SalesMan。Cpp 货郎担基类源文件  */
#include "StdAfx.h"
#include "SalesMan.h"
SalesMan::SalesMan() //构造函数，从文件中读取数值，生成图的邻接矩阵，
{//认为矩阵结点从0开始
     fstream fin("in.txt");
     if (!fin)
     {   
         cerr<<"file open failed!"<<endl;
         return;
     }
     int n;
     fin>>n;
     path.resize(n-1); //路径记录中间的那些结点
     //从文件里取值
     for (int i=0;i<n;i++)
     {
         vector<int> col;      
         for (int j=0;j<n;j++)
         {
              int num;
              fin>>num;
              col.push_back(num);
         }           
         matrix.push_back(col);
     }
     fin.close();
}
void SalesMan::PrintPath()
{
     cout<<0<<"/t";
     for (unsigned int i=0;i<path.size();i++)
         cout<<path[i]<<"/t";
     cout<<"0"<<endl;
}
void SalesMan::PrintMatrix()
{
     int n=(int)matrix.size();
     for (int i=0;i<n;i++)
     {
         for (int j=0;j<n;j++)
              cout<<matrix[i][j]<<"/t";
         cout<<endl;
     }
}
 
/* 文件名：Node.h  为BoundSalesMan所调用，结点数据结构 */
#pragma once
#include <vector>
using namespace std;
struct Node
{
public:
     int num;//约数
     int level; //层级
     int position; //当前结点
     vector<vector<int> > m; //当前结点的矩阵
     vector<int> states; //当前路径状态集
     Node(){};
     Node(int n,int l,int position,vector<int> path,vector<vector<int> > mValue);
     bool operator< (const Node & B)const
     {
          return num>B.num;
     }
};
/* 文件名：Node.cpp  为BoundSalesMan所调用，结点数据结构的实现 */
#include "StdAfx.h"
#include "Node.h"
Node::Node(int n,int l,int pos,vector<int> path,vector<vector<int> > mValue)
{
     num=n;  level=l;  position=pos;  states=path;  m=mValue;
}
 
 
分支限界法（优先队列）求旅行商问题
qq_55225576的博客
07-01 7474
1、问题描述： 旅行商问题（Traveling Salesman Problem，TSP）又译为旅行推销员问题、货郎担问题，简称为TSP问题，是最基本的路线问题，该问题是在寻求单一旅行者由起点出发，通过所有给定的需求点之后，最后再回到原点的最小路径成本。最早的旅行商问题的数学规划是由Dantzig等人提出。 要求：随机生成顶点数为n的图，利用优先队列式分支限界法完成旅行商问题求解。 2、分支限界法： 分支限界法常以广度优先或以最小耗费（最大效益）优先的方式搜索问题的解空间树。在分支限界法中，每一个活
分支限界求解旅行商/货郎担问题 python
qq_37163152的博客
06-22 1698
问题陈述: 设G(V,E)是一带权有向图,V={1,2,…n }, 其耗费矩阵C=(ci,j)当(i, j) E时,记 ci,j= 且 ci,i= .问如何选择周游路线使耗费最小。 算法思路： 在本文中使用了图G的归约矩阵。如果矩阵的一行（列）至少包含一个零元素且其余元素均为非负，则此行（列）称为已归约行（列）。所有行和列均为已归约和列的矩阵成为归约矩阵。 可以通过对一行（列）中每个...
分支限界法 旅行商 售货 问题 货郎问题
qq_44575910的博客
05-29 1380
用分支限界法解决旅行商问题。之前读书咋读读不懂，在网上也没找到啥好解释或者找到了也不是书中的同一种方法。 这几天啃书才读懂了一些。不得不说，书上设计的算法还是很巧妙的。 这里先给一些书上手写的解释，希望能对理解这个有所帮助。等过几天有空来详细讲一讲。 读的书是王晓东的《计算机算法设计与分析》。书中第六章分支限界法的内容。 谢谢阅读。 ...
货郎担问题算法 c语言实现,求解货郎担问题的分枝限界算法
weixin_36149065的博客
05-25 1176
#include#include #include #define TRUE (1)#define FALSE (0)#define MAX_CITIES (10)#define INFINITY(999)#define I INFINITYtypedef int bool;typedef struct _EDGE {int head;int tail;} EDGE;typedef struct...
利用分支限界法解决01背包和货郎担问题
weixin_44415974的博客
07-01 2116
利用分支限界法解决01背包和货郎担问题详细步骤       posted @ 2018-11-23 13:48  Charlie_ODD  阅读(...)  评论(...)  编辑  收藏 ...
【计算机算法设计与分析】——7.3利用分支限界法解决01背包和货郎担问题
weixin_30544657的博客
11-23 899
转载于:https://www.cnblogs.com/chihaoyuIsnotHere/p/10007086.html
优先队列式分支限界法解决旅行商问题.zip
04-22
旅行商问题（TSP）又译为旅行推销员问题、货郎担问题，简称为TSP问题，是最基本的路线问题，该问题是在寻求单一旅行者由起点出发，通过所有给定的需求点之后，最后再回到原点的最小路径成本。 “旅行商问题”常被...
旅行商问题
m0_53233211的博客
06-24 2323
旅行商问题（C++） 运用优先队列分支限界法 问题描述 旅行商问题（Traveling Salesman Problem，TSP）又译为旅行推销员问题、货郎担问题，简称为TSP问题，是最基本的路线问题，该推销员从一个城市出发，需要求得经过所有城市后，回到出发地的最小路径成本。 该问题的实质是从图论的角度来看，该问题实质是在一个带权完全无向图中，找一个权值最小的哈密顿回路。 解决方法 分支限界法：利用贪心方法求得上界，，优先队列式分支限界法用优先队列存储活结点表 算法分析 -对于TSP（旅行商
旅行商问题的求解方法-人工智能课程论文.docx
最新发布
06-15
该问题亦被称为货郎担问题、邮递员问题或售货员问题，广泛应用于图论、算法设计与复杂性理论研究中。 TSP问题的提出最早可追溯至1759年欧拉研究的骑士周游问题，而后在1948年由美国RAND公司正式引入并命名。该问题...
货郎担问题（分支限界法）
m0_51204608的博客
06-26 2444
#include<iostream> #include<fstream> using namespace std; typedef int Type; #define N 5 #define ZERO_VALUE_OF_TYPE 0 #define MAX_VALUE_OF_TYPE 2147483647 typedef struct node_data{ Type c[N][N]; //费用矩阵 int row_init[N]; //费用矩阵的当前行映射为
算法分析与设计 回溯法 分支界限法 货郎担
12-17
算法分析与设计 中国科学技术大学 有关分支界限法的补充 货郎担问题的最优求解
货担郎问题 C++ 算法设计
12-15
货担郎问题：在多个城市之间找到一条旅行路线，仅经过每个城市一次，且使旅行费用最少 内附报告
货郎担问题
04-06
离散数学的货郎担问题的课设 自己做的
TSP货郎担问题源码
04-11
TSP货郎担应用动态归划法求解 求从某个节点出发, 遍历余下n-1各节点后再回到出发点的最小成本周游路线.
依靠队列搜索——分支限界法及其应用：最大团问题、货郎问题
qq_41926985的博客
04-29 9399
人生是需要做好规划的，就算是混这人生也要混出个名堂出来。 全国有大部分人知道考研，但是考出来干什么，走什么的路是真的没有想法。 计算机行业涉及到许许多多的领域，所以，大学期间要学计算机专业，一定要做好规划，想做什么才能去学什么。囫囵吞枣只会让你啥也没有学到，说明白点就只是让你明白个大概，而不能明白所以然。 所以要定好方向，，将来想干什么，然后在这条路上学懂专业，这样到了社会，才能给你这一席之地。 ...
求解货郎担问题的分枝限界算法图形演示
chubi2239的博客
05-01 653
/* * File: tsp.c * Description: 求解货郎担问题的分枝限界算法图形演示 * Branch-and-bound algorithm to solve the * travelling salesman problem. CG ...
装载问题 -- 分支限界法
matafeiyanll的博客
05-14 3573
装载问题 – 分支限界法 装载问题描述 分支限界法的搜索策略 在当前节点（扩展节点）处，先生成其所有的儿子节点（分支），然后再从当前的活节点（当前节点的子节点）表中选择下一个扩展节点。为了有效地选择下一个扩展节点，加速搜索的进程，在每一个活节点处，计算一个函数值（限界），并根据函数值，从当前活节点表中选择一个最有利的节点作为扩展节点，使搜索朝着解空间上有最优解的分支推进，以便尽快地找出一个最优解。分支限界法解决了大量离散最优化的问题。 选择方法 1.队列式（FIFO）分支限界法 队列式分支限界法将活节点
算法分析：货郎担问题求解分析
【虎.无名】之JavaEye
07-22 2595
【虎.无名】看到一个帖子 【迷题：走遍全国各省会的最短路线问题 】http://www.iteye.com/topic/214846  想起以前上MSE时候做的一个《算法》的课程设计。数据如下：   城市 北京 上海 天津 石家庄 太原 呼和浩特 沈阳 长春 哈尔滨 济南 南京 合肥 杭州 南昌 福州 台北 郑州 武汉 长沙 广州 海口 南宁 西安 银川 兰州 西宁 乌鲁木齐 成都 贵阳 昆明 拉...
旅行商问题的实际应用探索与解析
而“旅行商问题”和“货郎担问题”是对同一问题的不同称呼，它们均指向同一类问题的求解，即寻找一条成本最低或距离最短的路径，以访问一系列节点或城市。 文件名称“旅行商问题在实际生活中的应用.docx”表明该...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值