哈密顿回路

已经发给你了。我的账号是zxkjack123@163.com.查收后请给分

哈密顿图（哈密尔顿图）（英语：hamiltonianpath，或traceablepath）是一个无向图，由天文学家哈密顿提出，由指定的起点前往指定的终点，途中经过所有其他节点且只经过一次。在图论中是指含有哈密顿回路的图，闭合的哈密顿路径称作哈密顿回路（hamiltoniancycle），含有图中所有顶点的路径称作哈密顿路径。

哈密顿图（哈密尔顿图）（英语：Hamiltonian path，或Traceable path）是一个无向图，由天文学家哈密顿提出，由指定的起点前往指定的终点，途中经过所有其他节点且只经过一次。在图论中是指含有哈密顿回路的图，闭合的哈密顿路径称作哈密顿回路（Hamiltonian cycle），含有图中所有顶点的路径称作哈密顿路径。

是。密顿图（哈密尔顿图)（英语：Hamiltonian graph，或Traceable graph）是一个无向图，由天文学家哈密顿提出，由指定的起点前往指定的终点，途中经过所有其他节点且只经过一次。在图论中是指含有哈密顿回路的图，闭合的哈密顿路径称作哈密顿回路，遗传算法是求tsp问题的最短路径，我们是对函数进行优化，属于局部的优化，该算法找到的哈密顿回路很可能是局部的最优解，本次遗传算法要进行的是一种全局优化，尽可能的找到符合条件的哈密顿回路。

天文学家哈密顿(William Rowan Hamilton) 提出，在一个有多个城市的地图网络中，寻找一条从给定的起点到给定的终点沿 途恰好经过所有其他城市一次的路径。这个问题和著名的七桥问题的不同之处在于，过桥只需要确定起点，而不用确定终点。哈密顿问题寻找一条从给定的起点到给定的终点沿 途恰好经过所有其他城市一次的路径。

　哈密顿图:图G的一个回路,若它通过图的每一个节点一次,且仅一次,就是哈密顿回路.存在哈密顿回路的图就是哈密顿图.哈密顿图就是从一点出发,经过所有的必须且只能一次,最终回到起点的路径.图中有的边可以不经过,但是不会有边被经过两次.n阶完全图中哈密顿回路的条数为：（n-1)!/2选定一个点，从这点开始到每个点的走法，只要有三个点以上就是圈，因此只管走的方法，选定构成一个圈的点算了两次，所以要除以2。若一个图的每一对不同顶点恰有一条边相连，则称为完全图。完全图是每对顶点之间都恰连有一条边的简单图。n个端点的完全图有n个端点及n(n − 1) / 2条边，以Kn表示。它是(k − 1)-正则图。所有完全图都是它本身的团。你算出的那个是无项完全图的条数吧。设Kn的每一条哈密顿回路是v1,v2...vn,v1v1,v2...vn对应完全图顶点的一个全排列所以Kn中不同的哈密顿回路有N!条。

在图中找出一条包含所有结点的闭路，并且，出来起点和重点重合外，这条闭路所含结点是互不相同的 可以在多项式时间类判断一个回路是否是哈密顿回路 但目前没有算法直接解出哈密顿回路 天文学家哈密顿(William Rowan Hamilton) 提出，在一个有多个城市的地图网络中， 寻找一条从给定的起点到给定的终点沿 途恰好经过所有其他城市一次的路径。 这个问题和著名的过桥问题的不同之处在于，某些城市之间的旅行不 一定是双向的。比如A→B,但B→A是不允许的。 换一种说法，对于一个给定的网络，确定起点和终点后，如果存在一条路径，穿过这个网络，我们就说这个网络存在哈密顿路径。哈密顿路径问题在上世纪七十年代初，终于被证明是“NP完备”的。据说具有这样性质的问题，难于找到一个有效的算法。实际上对于某些顶点数不到100的网络，利用现有最好的算法和计算机也需要比较荒唐的时间（比如几百年）才能确定其是否存在一条这样的路径。

在图中找出一条包含所有结点的闭路，并且，出来起点和重点重合外，这条闭路所含结点是互不相同的 可以在多项式时间类判断一个回路是否是哈密顿回路 但目前没有算法直接解出哈密顿回路 天文学家哈密顿(William Rowan Hamilton) 提出，在一个有多个城市的地图网络中， 寻找一条从给定的起点到给定的终点沿 途恰好经过所有其他城市一次的路径。 这个问题和著名的过桥问题的不同之处在于，某些城市之间的旅行不 一定是双向的。比如A→B,但B→A是不允许的。 换一种说法，对于一个给定的网络，确定起点和终点后，如果存在一条路径，穿过这个网络，我们就说这个网络存在哈密顿路径。哈密顿路径问题在上世纪七十年代初，终于被证明是“NP完备”的。据说具有这样性质的问题，难于找到一个有效的算法。实际上对于某些顶点数不到100的网络，利用现有最好的算法和计算机也需要比较荒唐的时间（比如几百年）才能确定其是否存在一条这样的路径。

n阶完全图中哈密顿回路的条数为：（n-1)!/2选定一个点，从这点开始到每个点的走法，只要有三个点以上就是圈，因此只管走的方法，选定构成一个圈的点算了两次，所以要除以2。若一个图的每一对不同顶点恰有一条边相连，则称为完全图。完全图是每对顶点之间都恰连有一条边的简单图。n个端点的完全图有n个端点及n(n−1)/2条边，以Kn表示。它是(k−1)-正则图。所有完全图都是它本身的团（clique）。

设Kn的每一条哈密顿回路是v1,v2...vn,v1v1,v2...vn对应完全图顶点的一个全排列所以Kn中不同的哈密顿回路有N!条K3是3!=6K4是4!=24K5是5!=120

可以用蚁群算法, 当然Hopfield网络与退火我也试过, 但还是蚁群的效果最好.注意: 哈密顿回路问题(TSP问题)是NP-COMPLETE问题, 问题规模比较大时无法求得最优解, 只能通过启发式算法逼近其次优解.把你的邮箱留下来吧. 我这有一份C++写的, 不过封装成MEX了, MATLAB里可以直接调用的, 速度还不错. 纯MATLAB的我也有, 不过速度慢死. 要不然我就不费事用C++重写一份了.留邮箱吧.

(n-1)的阶乘除以2

设Kn的每一条哈密顿回路是v1,v2...vn,v1v1,v2...vn对应完全图顶点的一个全排列所以Kn中不同的哈密顿回路有N!条K3是3!=6K4是4!=24K5是5!=120Kn是n!条

一个相当猥琐的数学归纳，直接证m=(n-1)(n-2)/2+2的情形……n=3时显然成立，n=k成立，n=k+1时要在图上加k-1条边，而k-1>3-1=2，也就是说在n=k的基础上绕道走第k+1个点就行了（加的k-1条边必须至少2条加载第k+1个点上，要不余下的n=k的那个子图就强连通了）

同学你好，我是吕卫锋院长，我希望你可以自己来做这一道题，做一个自主思考的北航学子，以后的回复将会被屏蔽。

依据判断1包含顶点图, 任意两顶点度数都于n-1（即于等于n-1）, 则存哈密尔顿通路2包含顶点图, 任意两顶点度数都于n（即于等于n）, 则存哈密尔顿路存哈密尔顿路存哈密尔顿路通路(连通)路（任意顶点发都该顶点）

哈密顿回路的算法是指:在图论中是指含有哈密顿回路的图，闭合的哈密顿路径称作哈密顿回路。哈密顿图（哈密尔顿图）（英语：Hamiltonian path，或Traceable path）是一个无向图，由天文学家哈密顿提出，由指定的起点前往指定的终点，途中经过所有其他节点且只经过一次。这个问题和著名的七桥问题的不同之处在于，过桥只需要确定起点，而不用确定终点。哈密顿问题寻找一条从给定的起点到给定的终点沿 途恰好经过所有其他城市一次的路径。

在一个回路中，除了经过初始结点两次以外，恰好经过每个结点 一次 ，则称此回路为哈密顿回路，哈密顿回路中每个结点都为偶结点 通过上述几点，可得出上图中不存在哈密顿回路 这个问题是基于寻找哈密顿回路的基础上，只不过所对应的图是加权无向图，在接下来。 这一篇的内容就到此为止了，接下来会有一篇文章专门介绍旅行推销员问题问题，谢谢大家！

答：没有什么更好的办法。有一个必要条件，可用它判断哪个图没有哈密顿回路。若图G=<V,E>中具有一条哈密顿回路，则对于结点集V的每个非空子集S均有W(G-S)£ |S|成立，其中W(G-S)是（G-S）中连通分支数。

/*数据的存储结构为邻接多重表，解题的思路是深度优先递归再配合回溯算，特别注意的是对顶点和边的访问、禁用、还原、进栈、出栈等操作，因本人才C语言几个月代码不够规范，代码可行性还待检验，仅供学习交流使用，如有需改善或未考虑到的细节请各位大神指出！*/#include<stdio.h>#include<windows.h>#include<string.h>#include<stdlib.h>#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0#define MAX_VER_NUM 11//顶点的最大数#define MAX_ARC_NUM 22//边的最大数typedef char VertexType;typedef int Status;typedef struct EdgeInfo{VertexType v1;VertexType v2;int weight;}EdgeInfo;typedef struct ArcBox//边所包含的信息{int iver;struct ArcBox *ilink;int jver;struct ArcBox *jlink;int weight;//权值int mark;char *info;}ArcBox;typedef struct VerBox//顶点所包含的信息{VertexType data;//顶点值ArcBox *firstedge;//指向邻接点（边所包含的信息）}VerBox;typedef struct Graph{int vernum;//顶点总个数int arcnum;//边的总个数VerBox vertexs[MAX_VER_NUM];//顶点信息}Graph;typedef struct StackData//栈中可存放的数据{VertexType data;int lenght;struct StackData *pnext;}StackData;typedef struct Stack//栈用于存放已访问过的顶点{struct StackData *ptop;struct StackData *pbottom; }STNODE;typedef struct Stack_Arc//存方已访问过的边及顶点{ArcBox *p[MAX_ARC_NUM];int v_num[MAX_ARC_NUM];}SANode;int Visited[MAX_VER_NUM];//标记顶点是否被访问过EdgeInfo Data[MAX_ARC_NUM]={{"A","B",324},{"A","J",419},{"A","K",328},{"A","D",241},{"A","C",556},{"A","F",703},{"A","G",521},{"B","G",391},/**************************/{"B","H",230},{"B","I",356},{"B","J",220},{"C","F",642},{"C","E",337},{"D","F",829},{"D","K",334},{"E","F",581},/**************************/{"E","G",1254},{"F","G",887},{"G","H",242},{"H","I",249},{"I","J",713},{"J","K",398}};//边及权值int Count=0;//记可走边的总数STNODE Stack;//存放已访问过SANode Store_Arc_Ver;//存放弧的信息及顶点信息int LAV=-1,ALL=0;int Short_Len=1000000,Short_Load=0;//存放最断最路经void CreateGraph(Graph **G);//创建图int LocateVer(Graph G,VertexType v);//查找顶点v在图中的位置void ShowAdjInfo(Graph *G);//查看邻接点信息int FirstAdjVer(Graph *G,int v,ArcBox **u);//第一邻接点int NextAdjVer(Graph *G,int v,int w,ArcBox **u);//下一邻接点void NAV(ArcBox *p,int *n,int v,int w,ArcBox **u);//递归查找下一邻接点void InitArcBox_mark(ArcBox *p);//初始化mark的值void DFSTraverse(Graph *G);//深度优先遍历图void DFST(Graph *G,int v);//剃归深度优先遍历void InitStack(void);//初始化栈void Push(VertexType c);//数据进栈void Pop(void);//出栈void PrintfArc(ArcBox *p);//打印弧的信息Status IsAdj(int *len,VertexType v);//判断栈顶的点是否与A为邻接点int main(){Graph *G=NULL;CreateGraph(&G);printf("顶点的邻接表： ");ShowAdjInfo(G);printf(" ");printf("可走路径结果: ");DFSTraverse(G);printf(" ");printf("可走路径总数:%d条；最短路径为:路径%d，长度为:%d ",ALL,Short_Load,Short_Len);return 0;}void CreateGraph(Graph **G)//创建图{int i,j,k,w;char v1,v2;ArcBox *pnew;(*G)=(Graph *)malloc(1*sizeof(Graph));if((*G)==NULL){printf("动态内存分配失败，程序终止！ ");exit(-1);}(*G)->arcnum=MAX_ARC_NUM;(*G)->vernum=MAX_VER_NUM;for(i=0;i<(*G)->vernum;i++){(*G)->vertexs[i].data="A"+i;(*G)->vertexs[i].firstedge=NULL;}for(k=0;k<(*G)->arcnum;k++){v1=Data[k].v1;v2=Data[k].v2;w=Data[k].weight;i=LocateVer((**G),v1);j=LocateVer((**G),v2);if(i>=0&&j>=0){pnew=(ArcBox *)malloc(1*sizeof(ArcBox));if(pnew==NULL){printf("动态内存分配失败，程序终止！ ");exit(-1);}pnew->iver=i;pnew->jver=j;pnew->weight=w;pnew->mark=FALSE;pnew->ilink=(*G)->vertexs[i].firstedge;pnew->jlink=(*G)->vertexs[j].firstedge;(*G)->vertexs[i].firstedge=pnew;(*G)->vertexs[j].firstedge=pnew;}else{printf("注意：*****顶点%c不存在！***** ",i<0?v1:v2);}}return;}int LocateVer(Graph G,VertexType v)//查找顶点v在图中的位置{int i,result=-1;for(i=0;i<MAX_VER_NUM;i++){if(G.vertexs[i].data==v){result=i;break;}}return result;}void ShowAdjInfo(Graph *G)//查看邻接点信息{int v,w;ArcBox *u;for(v=0;v<G->vernum;v++){printf("[%d|%c]",v,G->vertexs[v].data);for(w=FirstAdjVer(G,v,&u);w>=0;w=NextAdjVer(G,v,w,&u)){printf("->[%d|%c|%d]",w,G->vertexs[w].data,u->weight);}InitArcBox_mark(G->vertexs[v].firstedge);printf(" ");}}int FirstAdjVer(Graph *G,int v,ArcBox **u)//第一邻接点{int w=-1;ArcBox *p;p=G->vertexs[v].firstedge;(*u)=p;if(v==p->iver){w=p->jver;p->mark=TRUE;}else if(v==p->jver){w=p->iver;p->mark=TRUE;}return w;}int NextAdjVer(Graph *G,int v,int w,ArcBox **u)//下一邻接点{int n=-1;ArcBox *p;(*u)=NULL;p=G->vertexs[v].firstedge;NAV(p,&n,v,w,&(*u));return n;}void NAV(ArcBox *p,int *n,int v,int w,ArcBox **u)//递归查找下一邻接点{if(p->mark==FALSE && (p->iver==v ||p->jver==v)){(*u)=p;if(p->iver==v){*n=p->jver;p->mark=TRUE;}else if(p->jver==v){*n=p->iver;p->mark=TRUE;}else printf("下一邻接点数据出错，请检查！ ");}else{if(p->ilink!=NULL && *n==-1){NAV(p->ilink,n,v,w,&(*u));}if(p->jlink!=NULL && *n==-1){NAV(p->jlink,n,v,w,&(*u));}}return;}void InitArcBox_mark(ArcBox *p)//初始化mark的值{p->mark=FALSE;if(p->ilink!=NULL){InitArcBox_mark(p->ilink);}if(p->jlink!=NULL){InitArcBox_mark(p->jlink);}return;}void DFSTraverse(Graph *G)//深度优先遍历图{int v;for(v=0;v<G->vernum;v++){Visited[v]=FALSE;InitArcBox_mark(G->vertexs[v].firstedge);}InitStack();DFST(G,0);return;}void DFST(Graph *G,int v)//剃归深度优先遍历{int w=-1,flag=1,i=0,enter=1,len=0;ArcBox *u;//邻接点StackData *p;Visited[v]=TRUE;Count++;Push(G->vertexs[v].data);if(Count==11&&IsAdj(&len,Stack.ptop->data)==1){ALL++;printf("路径%-2d：",ALL);printf("A");p=Stack.ptop;len=len+p->lenght;if(Short_Len>len) Short_Load=ALL,Short_Len=len;while(p!=Stack.pbottom){printf("->%c",p->data);p=p->pnext;}printf(" 总长度为：%d",len);printf(" ");}for(w=FirstAdjVer(G,v,&u);w>=0;w=NextAdjVer(G,v,w,&u)){enter=1;for(i=0;i<=LAV;i++){if(Store_Arc_Ver.p[i]==u){enter=0;break;}}if(enter==1){Store_Arc_Ver.p[++LAV]=u;Store_Arc_Ver.v_num[LAV]=v;}if(Visited[w]==FALSE){DFST(G,w);Visited[w]=FALSE;Count--;Pop();}}for(LAV;Store_Arc_Ver.v_num[LAV]==v&&LAV>=0;)//还原当前顶点边的状态并出栈{Store_Arc_Ver.p[LAV]->mark=FALSE;Store_Arc_Ver.p[LAV]=NULL;LAV--;}}void InitStack(void)//初始化栈{Stack.pbottom=Stack.ptop=(StackData *)malloc(1*sizeof(StackData));Stack.pbottom->pnext=NULL;return;}void Push(VertexType c)//数据进栈{StackData *pnew;char v1,v2;int i;pnew=(StackData *)malloc(1*sizeof(StackData));pnew->data=c;if(c=="A"){pnew->lenght=0;}else{v1=c;v2=Stack.ptop->data;for(i=0;i<MAX_ARC_NUM;i++){if((v1==Data[i].v1 || v1==Data[i].v2) && (v2==Data[i].v1 || v2==Data[i].v2)){pnew->lenght=Stack.ptop->lenght+Data[i].weight;}}}pnew->pnext=Stack.ptop;Stack.ptop=pnew;return;}void Pop(void){StackData *p;p=Stack.ptop;Stack.ptop=p->pnext;free(p);}void PrintfArc(ArcBox *p){printf("[%d|%d|%d|%d] ",p->iver,p->jver,p->mark,p->weight);if(p->ilink!=NULL){PrintfArc(p->ilink);}if(p->jlink!=NULL){PrintfArc(p->jlink);}}Status IsAdj(int *len,VertexType v)//判断是栈顶的点是否与A为邻接点{int i;for(i=0;i<MAX_ARC_NUM;i++){if((Data[i].v1==v&&Data[i].v2=="A")||(Data[i].v1=="A"&&Data[i].v2==v)){*len=Data[i].weight;return TRUE;break;}}return FALSE;}

在图中找出一条包含所有结点的闭路，并且，出来起点和重点重合外，这条闭路所含结点是互不相同的 可以在多项式时间类判断一个回路是否是哈密顿回路 但目前没有算法直接解出哈密顿回路 天文学家哈密顿(William Rowan Hamilton) 提出，在一个有多个城市的地图网络中， 寻找一条从给定的起点到给定的终点沿 途恰好经过所有其他城市一次的路径。 这个问题和著名的过桥问题的不同之处在于，某些城市之间的旅行不 一定是双向的。比如A→B,但B→A是不允许的。 换一种说法，对于一个给定的网络，确定起点和终点后，如果存在一条路径，穿过这个网络，我们就说这个网络存在哈密顿路径。哈密顿路径问题在上世纪七十年代初，终于被证明是“NP完备”的。据说具有这样性质的问题，难于找到一个有效的算法。实际上对于某些顶点数不到100的网络，利用现有最好的算法和计算机也需要比较荒唐的时间（比如几百年）才能确定其是否存在一条这样的路径。

辰曦~文若题解-1122. Hamiltonian Cycle (25)-判断路径是否是哈密顿回路先来扩展一下知识哈密顿图：哈密顿图是一个无向图，由指定的起点通往指定的重点，途中经过所有节点有且只经过一次。在图论中，通常指的是哈密顿回路，即经过图中所有顶点有且只有一次，最终回到出发点。哈密顿回路为NP完全问题，暂不存在多项式内的解法。欧拉图：类似的有欧拉图：图中经过每天边有且只有一次，若最终回到出发点，则是欧拉回路。判断是否存在欧拉回路，是有定理的，网上可以找找。然而这道题给出了路径，判断是否是哈密顿回路，瞬间感觉题目档次下降了好多有没有！！！满足了以下条件即输出YES，只要有不满足的就输出NO：1.路径节点个数等于n+12.相邻点之间存在连通的边3.前n点各只出现过1次4.第一个节点等于最后一个节点，构成回路

n阶完全图中哈密顿回路的条数为：（n-1)!/2选定一个点，从这点开始到每个点的走法，只要有三个点以上就是圈，因此只管走的方法，选定构成一个圈的点算了两次，所以要除以2。若一个图的每一对不同顶点恰有一条边相连，则称为完全图。完全图是每对顶点之间都恰连有一条边的简单图。n个端点的完全图有n个端点及n(n−1)/2条边，以Kn表示。它是(k−1)-正则图。所有完全图都是它本身的团（clique）。

#include <queue>#include <cstdio>#include <set>#include <string>#include <stack>#include <cmath>#include <climits>#include <map>#include <cstdlib>#include <iostream>#include <vector>#include <algorithm>#include <cstring>#define max(a,b) (a>b?a:b)using namespace std;typedef long long(LL);typedef unsigned long long(ULL);const double eps(1e-8);char B[1<<15],*S=B,*T=B,ch;#define getc() (S==T&&(T=(S=B)+fread(B,1,1<<15,stdin),S==T)?0:*S++)int aa,bb; int F(){      while(ch=getc(),(ch<"0"||ch>"9")&&ch!="-"); ch=="-"?aa=bb=0:(aa=ch-"0",bb=1);      while(ch=getc(),ch>="0"&&ch<="9")aa=aa*10+ch-"0"; return bb?aa:-aa;}#define N 100010int n,swp,cnt,z[N]; long long ans;#define swap(a,b) (swp=a,a=b,b=swp)#define abs(x) (x>0?x:-(x))#define max(a,b) (a>b?a:b)#define cmax(x) (ans<x?ans=x:1)struct P {int x,y,id,nx,ny;} p[N];bool operator<(const P&a,const P&b) {return a.nx<b.nx||a.nx==b.nx&&a.ny<b.ny;}class Graph{private:      int et,la[N],ufs[N],tot;      struct D      {            int x,y,v;            bool operator<(const D&a)const {return v<a.v;}      } d[N<<2];      struct E {int to,v,nxt;} e[N<<1];      int gf(int x) {return ufs[x]==x?x:ufs[x]=gf(ufs[x]);}      void adde(int x,int y,int v)      {            e[++et]=(E) {y,v,la[x]},la[x]=et;            e[++et]=(E) {x,v,la[y]},la[y]=et;      }public:      Graph() {et=1;}      void add(int x,int y,int v) {d[++tot]=(D) {x,y,v};}      void make()      {            std::sort(d+1,d+1+tot);            for(int i=1; i<=n; i++)ufs[i]=i; cnt=n;            for(int i=1,x,y; i<=tot; i++)                  if((x=gf(d[i].x))!=(y=gf(d[i].y)))                  {                        ufs[x]=y,cnt--,ans+=d[i].v,                                            adde(d[i].x,d[i].y,d[i].v);                  }      }} G;struct D {int x,n;} d[N];bool operator<(const D&a,const D&b) {return a.x<b.x;}#define dis(i,j) (abs(p[i].x-p[j].x)+abs(p[i].y-p[j].y))void ins(int i){      for(int t=p[i].ny; t<=cnt; t+=t&-t)            if(z[t]==0||p[z[t]].x+p[z[t]].y<p[i].x+p[i].y)z[t]=i;}int query(int i){      int f=0;      for(int t=p[i].ny; t>0; t-=t&-t)            if(z[t]&&(f==0||p[z[t]].x+p[z[t]].y>p[f].x+p[f].y))f=z[t];      return f;}void work(){      for(int i=1; i<=n; i++)p[i].nx=p[i].x-p[i].y,p[i].ny=p[i].y;      std::sort(p+1,p+1+n);      for(int i=1; i<=n; i++)d[i]=(D) {p[i].ny,i};      std::sort(d+1,d+1+n); d[n+1].x=d[n].x; cnt=1;      for(int i=1; i<=n; i++)      {            p[d[i].n].ny=cnt;            if(d[i].x!=d[i+1].x)cnt++;      }      memset(z,0,sizeof(z));      for(int i=1,j; i<=n; ins(i++))            if(j=query(i))G.add(p[i].id,p[j].id,dis(i,j));}int main(){      n=F();      for(int i=1; i<=n; i++)p[i]=(P) {F(),F(),i}; work();      for(int i=1; i<=n; i++)swap(p[i].x,p[i].y); work();      for(int i=1; i<=n; i++)p[i].y=-p[i].y; work();      for(int i=1; i<=n; i++)swap(p[i].x,p[i].y); work(); G.make();      printf(%lld ,ans);}/** this code is made by crazyacking* Verdict: Accepted* Submission Date: 2015-09-11-15.31* Time: 0MS* Memory: 137KB*/

可以用蚁群算法, 当然Hopfield网络与退火我也试过, 但还是蚁群的效果最好.注意: 哈密顿回路问题(TSP问题)是NP-COMPLETE问题, 问题规模比较大时无法求得最优解, 只能通过启发式算法逼近其次优解.把你的邮箱留下来吧. 我这有一份C++写的, 不过封装成MEX了, MATLAB里可以直接调用的, 速度还不错. 纯MATLAB的我也有, 不过速度慢死. 要不然我就不费事用C++重写一份了.

这是一个典型的旅行商问题，或者叫货郎担问题，网上应该有很多源程序，你可以搜索一下。一般而言典型的是两种算法：分支与界法和贪心算法，不过随着算法的发展出现了不少好的典型解法。

你看看我这个用SQL实现的, 在SQL SERVER上可以执行.希望对你有帮助.

证：显然，哈密尔顿回路中每个点的度数均为2，且不能含有更小的回路。假设哈密尔顿回路中含e1不含e2，则回路中必含边dc和de。由于回路中不能有ce（否则decd构成回路），因而回路中必含边cb和ea，故回路中不能含e1（否则deabcd构成回路），这与条件矛盾，故假设不成立，证毕。

你等于10等于10厘米，为什么？ 国际公认的十进位的计算方法。长度以毫米。厘米，分米，米，为计算的基本单位。10mm=1cm.，厘米等于1dm。10dm=1m.，这种定位方法，利益计算对国民经济的各个方面都有大的好处，如果二进位，古代16进位。计算起来非常繁琐。不适合现在的计算工具使用，

这个很简单，如果是作业题的话。因为如果是作业题，那么很可能你课堂上学过这样一个定理：若每2个点的度数之和大于等于n，则有Hamiltonian回路。就用这个定理就可以了。具体方法：完全图，总共有：n(n-1)/2条边。那么，G最多比完全图少了：n(n-1)/2-(n-1)(n-2)/2-2=n-3条边。下面，我们来看看G中两个顶点的度数之和，最少是多少。完全图中，两个顶点度数之和为：2(n-1)现在少了n-3条边，最极端的情形，这n-3条边均与某两个顶点相连，而且其中1条边还是连接这2个顶点的。于是，这2个顶点最多少了n-2的度数，也就是还剩：2(n-1)-(n-2)=n度数。所以，符合那个定理，有H回路。

欧拉回路是经过所有边一次然后回到原点，哈密顿是经过所有节点一次然后回到原点，tsp问题就是哈密顿回路