旅行商问题
np难问题的例子
NP难问题的例子
NP难问题是指那些在多项式时间内无法被解决的问题，它们通常被认为是计算机科学中的最难问题之一。
以下是一些著名的NP难问题的例子：
1. 旅行商问题（Traveling Salesman Problem，TSP）：该问题的目标是找到一条最短路径，使得一个商人能够访问所有城市，并返回起点城市。
这个问题在实践中是非常复杂的，因为它涉及到很多因素，如城市之间的距离、商人的时间限制、交通拥堵等等。
尽管TSP是一个NP难问题，但在理论上是否存在一个多项式时间算法还是未知的。
2. 着色问题（House染色问题）：该问题涉及到将房子涂成不同的颜色，以避免相邻房子颜色相同。
该问题在计算机图形学中具有重要应用，但也是一个NP难问题。
3. 子集问题（Subset Sum Problem）：该问题是判断给定一组数是否存在一个子集，使得这些数的和等于给定的目标值。
这个问题也是一个NP难问题，尽管它可以在多项式时间内被近似解决。
4. 数独问题（Sudoku）：数独是一种数字填充游戏，需要将一个9x9的网格填充为1到9的数字，使得每一行、每一列以及每一个子网格中的数字都不重复。
数独是一个NP 难问题，尽管它可以在多项式时间内被近似解决。
这些例子表明，尽管NP难问题在实践中具有重要的应用，但我们仍需要更多的研究来解决这些问题。
组合优化中的旅行商问题
组合优化中的旅行商问题组合优化问题是指在给定的集合或者结构中，寻找一个最优解或者一个近似最优解的问题。
而旅行商问题是组合优化中的一个经典问题，也是一个NP困难问题。
它的问题描述是：给定一些城市和它们之间的距离，求解一个最短路径，使得每个城市只经过一次，并且最后能够回到起始城市。
旅行商问题在实际生活中有着广泛的应用，比如物流配送、电路板布线、旅游路线规划等。
由于问题的复杂性，寻找解决该问题的最优算法一直是学术界和工业界的研究热点。
为了解决旅行商问题，已经提出了一系列的算法。
下面将介绍其中几种常见的算法。
1. 穷举法穷举法是最简单的解决旅行商问题的方法之一。
它的思想是对所有可能的路径进行穷举，计算路径的总长度，并选择其中最短的路径作为结果。
然而，由于旅行商问题的解空间巨大(复杂度是O(n!))，穷举法在问题规模较大时计算量会非常庞大，因此不适用于大规模问题。
2. 动态规划法动态规划法是另一种解决旅行商问题的常用方法。
它的思想是通过将问题分解成多个子问题，并利用子问题的最优解构造原问题的解。
具体来说，可以定义一个二维数组dp，其中dp[i][j]表示从城市i出发，经过集合j中的城市一次后，回到起始城市的最短路径长度。
通过动态规划的递推公式，可以求解出dp数组中的所有元素，从而得到整个问题的最优解。
3. 遗传算法遗传算法是一种基于生物进化和遗传机制的搜索算法。
它通过模拟生物进化过程中的选择、交叉和变异等操作，逐步优化解的质量。
在解决旅行商问题时，可以将每个可能的路径编码成一个染色体，并用适应度函数评估每个染色体的优劣。
然后通过选择、交叉和变异等操作，使得优秀的染色体得以传递下去，最终得到一个接近最优解的路径。
4. 其他启发式算法除了上述提及的算法，还有一些启发式算法常被用于解决旅行商问题，如蚁群算法、模拟退火算法和遗传算法等。
这些算法多为基于自然现象和启发式规则的搜索算法，可以有效地在大规模数据集上求解旅行商问题。
旅行商问题(TSP)
iS jS
除起点和终点外，各边不构成圈
xij
0, 1
(7 1) (7 2) (7 3)
5
0 8 5 9 12 14 12 16 17 22
8
0
9 15 17
8
11
18
14
22
5 9 0 7 9 11 7 12 12 17
9 15 7 0
lingo解决旅行商问题 model: sets: city/1..6/:u; link(city,city):dist,x; endsets data: dist=99999,702,454,842,2396,1196,
702,99999,324,1093,2136,764, 454,324,99999,1137,2180,798, 842,1093,1137,99999,1616,1857, 2396,2136,2180,1616,99999,2900, 1196,764,798,1857,2900,99999; enddata
C=v1,v2,…,vi,vj,…,vj-1,vi+1,vj+1,…,vm,v1 （3）C0C,重复步骤（2），直到条件不满足为止，最后得 到的C即为所求。
例对下图的K6,用二边逐次修正法求较优H圈.
较优H圈: 其权为W(C3)=192
分析: 这个解的近似程度可用最优H圈的权的下界与
其比较而得出.即利用最小生成树可得最优H圈的一个下界.
设C是G的一个最优H圈，则对G的任一顶点v, C-v是
G-v的生成树.如果T是G-v的最小生成树,且e1是e2与v关联
的边中权最小的两条边,则w(T)+w(e1)+w(e2)将是w(C)
智能优化-TSP-旅行商问题
智能优化实验报告基于遗传算法的TSP问题求解研究一、问题描述1、TSP问题的概述旅行商问题 (Traveling Salesman Problem，简称 TSP) 是一个经典的组合化问题。
它可以描述为：一个商品推销员要去若干个城市推销商品，从一个城出发需要经过所有城市后回到出发地，应如何选择行进路线以使总行程短。
从图论的角度看，该问题实质是在一个带权完全无向图中找一个权值最的小回路。
在寻找最短路径问题上，有时不仅要知道两个指定顶点间的最短路径，还需要知道某个顶点到其他任意顶点间的最短路径。
旅行商问题也是经典的组合数学的问题，生活中随处可见这类组合数学问题。
例如，计算下列赛制下的总的比赛次数:n个球队比赛，每队只和其他队比赛一次。
在纸上画一个网络，用铅笔沿着网络的线路走，在笔不离开纸面且不重复线路的条件下，一笔画出网络图。
一个邮递员从邮局出发，要走完他所管辖的街道，他应该选择什么样的路径，这就是著名的“中国邮递员问题”。
一个通调网络怎样布局最节省?美国的贝尔实验室和IBM公司都有世界一流的组合数学家在研究这个问题，这个问题直接关系到巨大的经济利益。
库房和运输的管理也是典型的组合数学问题，怎样安排运输使得库房充分发挥作用，进一步来说，货物放在什么地方最便于存取。
上述的这些例子中，其中一部分就和旅行商问题有关系。
2、TSP问题研究意义解决旅行商问题有着极其重要的理论和现实意义。
从理论层面来讲，解TSP不仅为其他算法提供了思想方法平台，使这些算法广泛地应用于各种组合优化问题；而且经常被用来测试算法的优劣，如模拟退火算法、禁忌搜索、神经网络、进化算法等，都可用旅行商问题来测试。
从实际应用层面来讲，旅行商问题作为一个理想化的问题，尽管多数的研究成果不是为了直接的应用，但却被广泛地转化为许多组合优化问题，最直接的就是其在交通、物流和大规模生产中的应用。
3、TSP问题的解决TSP问题是诸多领域内出现的多种复杂问题的集中概括和简化形式。
组合数学_旅行商问题
旅行商问题
1
问题描述 某售货员要到若干城市去推销商品，已知 各城市之间的路程(或旅费)。他要选定一 条从驻地出发，经过每个城市一次，最后 回到驻地的路线，使总的路程(或总旅费) 最小。
旅行商问题: 对正权完全图G，求G总长最短的H回路。
求解算法：分支限界算法
2
算法描述 旅行商问题的解空间是一个排列树。有两种实 现的方法。第一种是只使用一个优先队列，队 列中的每个元素 中都包含到达根的路径。另一 种是保留一个部分解空间树和一个优先队列， 优先队列中 的元素并不包含到达根的路径。以 下为第一种方法。
4
例
10 6
5
程序演示
6
运行结果
7
谢谢观看~~~
8
数学建模经典问题——旅行商问题
度最短的两条边之和； C*(T)：最优回路长度；
25
于是，dmin(i, 1)代表与第i个结点关联的所有边 中最长边的长度，dmin_j(i, 1) 代表与第i个结点关联 的所有边中次长边的另一个结点编号(其中一个结点 编号为i)，第i结点的dmin(i, k)和dmin_j(i, k)可由距 离矩阵w轻易求得。
20
当然，用该方法有时会找不到TSP的最优解， 因为很可能在进行了几轮迭代后，却找不到新的不 等式。Padborg与Hong曾计算了74个TSP，其中54 个得到了最优解，其余的虽未得到最优解，却得到 了很好的下界，如果与近似方法配合，可以估计近 似解的精确程度。如，他们解过一个有313个城市的 TSP，获得一个下界41236.46，而用近似方法能得 到一条长为41349的路线，于是可估计出所得近似解 与最优解的误差不超过0.26%。
14
早在1954年，Dantzig等人就曾提出过一种方 法（非多项式算法），并且求出了一个42城市的 TSP最优解。到了1960年代，不少人用分支定界法 解决了许多有几十个城市的TSP。还有人提出了一 些近似方法，也解决了许多有几十个城市甚至上百 个城市的TSP（有时找到的仅是近似解）。更值得 注意的是，从1970年代中期开始，Grotschel与 Padberg等人深入研究了TS多面体的最大面 （facet），并从所得结果出发获得了一种解TSP的 新算法，可以解决一些有100多个城市的TSP，且都 在不长的时间内找到了最优解。
一、数学模型 1. 标准TSP 旅行商问题（简称TSP），也称货郎担问题或 旅行推销员问题，是运筹学中一个著名的问题，其 一般提法为：有一个旅行商从城市1出发，需要到城 市2、3、…、n去推销货物，最后返回城市1，若任 意两个城市间的距离已知，则该旅行商应如何选择 其最佳行走路线
旅行商问题运筹学方法
旅行商问题运筹学方法我折腾了好久旅行商问题的运筹学方法，总算找到点门道。
说实话，刚开始接触旅行商问题的时候，我真是一头雾水。
就知道是要找一个旅行商经过所有城市并且最后回到起始城市的最短路线。
我一开始也是瞎摸索，想着把所有可能的路线都列举出来再比较长短不就得了。
但我很快就发现这根本行不通，城市数量稍微多一点，那可能的路线数量就像天文数字一样。
就好比你有10个城市，那可能的路线就有好多好多，我计算器都按不过来。
后来我就尝试用一些简单的启发式方法。
我记得我先试的是最近邻法。
这方法简单来说就像一个人很贪心一样，从起始城市出发，每一步都去离当前城市最近的没去过的城市。
但是这个方法有很大的缺陷。
有一次我用它来模拟一个比较复杂的城市网络布局的时候，得到的路线远不是最短的，因为它很容易就走进死胡同，只看到眼前的利益，而忽略了整体的规划。
再后来呢，我又了解到了节约算法。
这个算法就有点像是把局部的小节约累积成一个大的节约。
把两个城市看成一组，计算合并它们为一个行程可以节省多少路程，如果节省得多就把它们安排在一起。
这样一步一步地优化整个行程。
不过这个方法也不是完美的，它计算起来有时候也挺复杂，而且有可能在某些特殊布局下也得不到最优解。
我还试过蚁群算法，这算法挺有意思的，它是模拟蚂蚁找食物的过程。
每只蚂蚁在路上留下信息素，别的蚂蚁就根据信息素的浓度来选择路径，浓度越高就越有可能选择。
就像我们找美食，哪里人多我们就觉得哪里好吃的可能性大。
但是这个算法有个难点就是参数的设置。
我一开始不确定怎么设置那些参数，什么信息素挥发率之类的，就随便设了个值，结果得到的结果也不是很好，甚至有时候根本就不收敛，就一直在那绕圈子似的找路线。
到目前我觉得最好的方法就是把多种方法结合起来。
比如先用最近邻法快速得到一个初始解，然后再用节约算法或者其他方法在这个初始解的基础上进行优化。
这样既能快速得到一个解，又有可能接近最优解。
这就好比我们搭积木，先大致搭一个形状，然后再调整细节。
基于图论的旅行商问题求解算法研究
基于图论的旅行商问题求解算法研究1. 引言旅行商问题（Traveling Salesman Problem，简称TSP）是计算机科学中的经典问题，属于组合优化问题的范畴。
其基本思想是在给定的一组城市以及它们之间的距离或成本数据的情况下，找到一条最短的路径，使得路径经过每个城市且仅经过一次，最终回到起点城市。
2. 图论基础在研究旅行商问题之前，我们需要了解图论的基本概念。
图由节点（顶点）和边（连接节点的线段）组成。
对于旅行商问题，我们可以将每个城市视为一个节点，城市之间的距离视为边的权重。
3. 穷举法穷举法是最简单、最直接的求解方法。
它列举了所有可能的路径，并计算每条路径的总长度，最后选择最短的路径作为最优解。
然而，随着城市数量的增加，穷举法的复杂度呈指数级增长，因此对于大规模的问题来说，穷举法的效率非常低下。
4. 最小生成树法最小生成树法（Minimum Spanning Tree, MST）将图中的所有节点通过边连接起来，形成一棵树。
通过对最小生成树进行遍历，我们可以得到一条经过每个节点且最短的路径。
然而，最小生成树法并不能得到最优解，因为它忽略了必须回到起始城市的约束。
5. 动态规划法动态规划法是一种常用的求解旅行商问题的方法。
它基于以下两个关键思想：子问题最优性和子问题重叠性。
动态规划法通过对问题进行逐步分解，将大问题划分为较小的、重复的子问题。
通过求解子问题并利用子问题之间的关系，最终可以得到问题的最优解。
具体到旅行商问题，我们可以使用动态规划来求解。
6. 遗传算法遗传算法是一种基于自然界进化规律的启发式算法，常用于解决复杂的组合优化问题。
它通过构造一个种群，每个个体代表一种可行解，并通过模拟自然选择、交叉和变异等遗传操作来逐代进化种群。
最终，进化到一定代数时，得到的个体就是问题的近似最优解。
在求解旅行商问题时，我们可以使用遗传算法来搜索解空间，并不断优化路径的长度。
7. 蚁群算法蚁群算法受到蚂蚁找食物行为的启发，通过模拟蚂蚁在搜寻食物时的行为来求解优化问题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
算法设计与分析实验报告实验三旅行商问题院系：班级：计算机科学与技术学号：姓名：任课教师：成绩：湘潭大学2016年5月实验三旅行商问题一. 实验内容分别编程实现回溯法和分支限界法求TSP问题的最优解，分析比较两种算法的时间复杂度并验证分析结果。
二．实验目的1、掌握回溯法和分支限界法解决问题的一般步骤，学会使用回溯法和分支限界法解决实际问题；2、理解回溯法和分支限界法的异同及各自的适用范围。
三. 算法描述旅行商问题的回溯法算法可描述如下：Template <class Type>Class Traveling{friend Type TSP(int ** , int[],int ,Type);Private;Void Backtrack(int i);Int n, //图G的顶点数*x; //当前解*bestx; //当前最优解Type **a, //图G的邻接矩阵cc, //当前费用bestc， //当前最优解NoEdge; //无边标记}；Template <class Type>Void Traveling<Type> : : backtrack(int i){if(i ==n){if(a[x[n-1]][x[n]]!=NoEdge&&a[x[n]][1]!=NoEdge&&(cc+a[x[n-1]][x[n]]+a[x[n]][1] +a[x[n]][1]<bestc || bestc == NoEdge)){for(int j = 1;j<=n;j++) bestx[j] = x[j];bestc == cc + a[x[n-1]][x[n]]+a[x[n]][1]};}else{For (int j = i;j<= n;j++)//是否可进入x[j]子树？If(a[x[i-1]][x[j]] != NoEdge &&(cc+a[x[i-1]][x[j]] < bestc || bestc == NoEdge)){//搜素子树Swap(x[i],x[j]);cc += a[x[i-1]][x[i]];Backtrack(i + 1);cc -= a[x[i-1]][x[i]];Swap(x[i],x[j]);}}}Template<class Type>Type TSP(Type**a, int v[], int n, Type NoEdge){Traveling<Type> Y;//初始化YY.x = new int [n+1];//置x为单位排列For(int i = 1;i <= n;i++)Y.x[i] = i;Y.a = a;Y.n = n;Y.bestc = NoEdge;Y.bestx = v; = 0;Y.NoEdge = NoEdge;//搜索x[2:n]的全排列Y.Backtrack(2);Delete[]Y.x;Return Y.bestc;}算法效率：如果不考虑更新bestx所需的计算时间，则Backtrack需要O（（n-1）！）计算时间。
由于算法Backtrack在最坏情款下可能需要更新当前最优解O（（n-1）！）次，每次更新需O（n）计算时间，从而整个算法的计算时间复杂性为O（n！）。
旅行商问题的分支界限法算法可描述如下：使用优先队列来存储活节点，优先队列中的每个活节点都存储从根到该活节点的相应路径。
具体算法可描述如下：Template<class Type>Class MinHeapNode{firend Traveling<Type>;Public:Operator Type() const {return lcost;}Private:Type lcost, //子树费用的下界cc, //当前费用rcost； //x[s:n-1]中定点最小出边费用和Int s, //根节点到当前节点的路径为x[0:s]*x; //需要进一步搜索的顶点是x[s+1:n-1]};四. 算法实现源程序代码/*回溯法*/#include<stdio.h>#include<time.h>#define N 5double cc,//当前路径费用bestc;//当前最优解费用double a[N+1][N+1];//邻接矩阵，存放图的信息int bestx[N+1];//当前最优解int x[N+1];//当前解void inputAjac(){int i,j;for(i=1;i<=N;i++){ for(j=i+1;j<=N;j++){printf("请输入第%d个城市到第%d个城市所需路费为：",i,j);scanf("%lf",&a[i][j]);a[j][i]=a[i][j];}}}void backtrack(int i){if(i==N){if(a[x[N-1]][x[N]]>0.0&&a[x[N]][x[1]]>0.0){if(bestc<0.0||bestc>cc+a[x[N-1]][x[N]]+a[x[N]][x[1]]){int j;for(j=1;j<=N;j++){bestx[j]=x[j];bestc=cc+a[x[N-1]][x[N]]+a[x[N]][x[1]];}}}}else{int j;for(j=i;j<=N;j++){if(a[x[i-1]][x[j]]>0.0){if(bestc<0.0||bestc>cc+a[x[i-1]][x[j]]+a[x[j]][x[1]]){int temp;cc+=a[x[i-1]][x[j]];temp=x[i];x[i]=x[j];x[j]=temp;backtrack(i+1);temp=x[i];x[i]=x[j];x[j]=temp;cc-=a[x[i-1]][x[j]];}}}}}double tsp(){int i;for(i=1;i<=N;i++){x[i]=i;}cc=0.0,bestc=-1.0;inputAjac();backtrack(2);return bestc;}void output(){int i;for(i=1;i<=N;i++){printf("%4d",bestx[i]);}// printf("\n");}void main(){double start,finish;start=clock();//取开始时间printf("城市个数：5\n");printf("走%d个城市最少路费为：%lf\n",N,tsp());printf("路径:");output();printf(" 1\n");finish=clock();printf("所需时间 %f ms\n",(finish-start));}/*分支界限法*/#include <stdio.h>#include <istream>#include<time.h>using namespace std;#define MAX_CITY_NUMBER 10#define MAX_COST 10000000int City_Graph[MAX_CITY_NUMBER][MAX_CITY_NUMBER];int City_Size;int Best_Cost;int Best_Cost_Path[MAX_CITY_NUMBER];typedef struct Node {int lcost;int cc;int rcost;int s;int x[MAX_CITY_NUMBER];struct Node* pNext;} Node;typedef struct MiniHeap {Node* pHead;} MiniHeap;void InitMiniHeap(MiniHeap* pMiniHeap) { pMiniHeap->pHead = new Node;pMiniHeap->pHead->pNext = NULL;}void put(MiniHeap* pMiniHeap,Node node) { Node* next;Node* pre;Node* pinnode = new Node;pinnode->cc = ;pinnode->lcost = node.lcost;pinnode->pNext = node.pNext;pinnode->rcost = node.rcost;pinnode->s = node.s;pinnode->pNext = NULL;for(int k=0; k<City_Size; k++) {pinnode->x[k] = node.x[k];}pre = pMiniHeap->pHead;next = pMiniHeap->pHead->pNext;if(next == NULL) {pMiniHeap->pHead->pNext = pinnode;} else {while(next != NULL) {if((next->lcost) > (pinnode->lcost)) {pinnode->pNext = pre->pNext;pre->pNext = pinnode;break;}pre = next;next = next->pNext;}pre->pNext = pinnode;}}Node* RemoveMiniHeap(MiniHeap* pMiniHeap) {Node* pnode = NULL;if(pMiniHeap->pHead->pNext != NULL) {pnode = pMiniHeap->pHead->pNext;pMiniHeap->pHead->pNext = pMiniHeap->pHead->pNext->pNext;}return pnode;}void Traveler() {int i,j;int temp_x[MAX_CITY_NUMBER];Node* pNode = NULL;int miniSum;int miniOut[MAX_CITY_NUMBER];MiniHeap* heap = new MiniHeap;InitMiniHeap(heap);miniSum = 0;for (i=0; i<City_Size; i++) {miniOut[i] = MAX_COST;for(j=0; j<City_Size; j++) {if (City_Graph[i][j]>0 && City_Graph[i][j]<miniOut[i]) { miniOut[i] = City_Graph[i][j];}}if (miniOut[i] == MAX_COST) {Best_Cost = -1;return ;}miniSum += miniOut[i];}for(i=0; i<City_Size; i++) {Best_Cost_Path[i] = i;}Best_Cost = MAX_COST;pNode = new Node;pNode->lcost = 0;pNode->cc = 0;pNode->rcost = miniSum;pNode->s = 0;pNode->pNext = NULL;for(int k=0; k<City_Size; k++) {pNode->x[k] = Best_Cost_Path[k];}put(heap,*pNode);while(pNode != NULL && (pNode->s) < City_Size-1) {for(int k=0; k<City_Size; k++) {Best_Cost_Path[k] = pNode->x[k] ;}if ((pNode->s) == City_Size-2) {int edge1 =City_Graph[(pNode->x)[City_Size-2]][(pNode->x)[City_Size-1]];int edge2 =City_Graph[(pNode->x)[City_Size-1]][(pNode->x)[0]];if(edge1 >= 0 && edge2 >= 0 && (pNode->cc+edge1+edge2) <Best_Cost) {Best_Cost = pNode->cc + edge1+edge2;pNode->cc = Best_Cost;pNode->lcost = Best_Cost;pNode->s++;}} else { for (i=pNode->s; i<City_Size; i++) { if(City_Graph[pNode->x[pNode->s]][pNode->x[i]] >= 0) {int temp_cc = pNode->cc+City_Graph[pNode->x[pNode->s]][pNode->x[i]];int temp_rcost = pNode->rcost-miniOut[pNode->x[pNode->s]];if (temp_cc+temp_rcost<Best_Cost) {for (j=0; j<City_Size; j++) {temp_x[j]=Best_Cost_Path[j];}temp_x[pNode->x[pNode->s+1]] =Best_Cost_Path[i];temp_x[i] = Best_Cost_Path[pNode->s+1];Node* pNextNode = new Node;pNextNode->cc = temp_cc;pNextNode->lcost = temp_cc+temp_rcost;pNextNode->rcost = temp_rcost;pNextNode->s = pNode->s+1;pNextNode->pNext = NULL;for(int k=0; k<City_Size; k++) {pNextNode->x[k] = temp_x[k];}put(heap,*pNextNode);delete pNextNode;}}}}pNode = RemoveMiniHeap(heap);}}int main() {double start,finish;start=clock();int i,j;printf("城市个数：");scanf("%d",&City_Size);for(i=0; i<City_Size; i++) {printf("请分别输入每个城市与其它城市的路程花费：");for(j=0; j<City_Size; j++) {scanf("%d",&City_Graph[i][j]);}}Traveler();printf("最少路费：""%d\n",Best_Cost);finish=clock();printf("所需时间： %f ms\n",(finish-start));return 1;}五．程序运行结果回溯法结果截图：分支界限法结果截图：六．实验结果分析回溯法算法的时间复杂度为O(n！)，分支界限发算法的时间复杂度为O(2^n);从实验结果也可看出分支界限法所需时间少很多。