求解旅行商（货郎担）问题的五种方法

1.蛮力法

#include"Graph.cpp"
#include<stdio.h>
#include<vector>
using namespace std;
int s=0;
MGraph g;
int Count=1;
vector<vector<int> >ps;
void Insert(vector<int>s,int i,vector<vector<int>> &ps1){
	vector<int>s1;
	vector<int>::iterator it;
	for(int j=0;j<i;j++){
		s1=s;
		it=s1.begin()+j;
		s1.insert(it,i);
		ps1.push_back(s1);
	}
} 
void Perm(int n){
	vector<vector<int>> ps1;
	vector<vector<int>>::iterator it;
	vector<int>s,s1;
	s.push_back(1);
	ps.push_back(s);
	for(int i=2;i<=n;i++){
		ps1.clear();
		for(it=ps.begin();it!=ps.end();it++){
			Insert(*it,i,ps1);
		}
		ps=ps1;
	} 
}
void TSP(MGraph g,int s){
	vector<int>minpath;
	int minpath=INF;
	Perm(g.n-1);
	vector<vector<int>>::reverse_iterator it;
	vector<int>apath;
	int pathlen;
	printf("起点为%d的全部路径：",s);
	for(it=ps.rbegin();it!=ps.rend();it++){
		pathlen=0;
		int initv=s;
		apath=(*it);
		for(int i=0;i<(*it).size();i++){
			pathlen+=g.edges[initv][(*it)[i]];
			initv=(*it)[i];
		}
		pathlen+=g.edges[initv][s];
		if(pathlen<INF){
			printf("%d:",Count++);
			cout<<"0->";
			for(int i=0;i<apath.size();i++){
				printf("%d->",apath[i]);
			}
			printf("%d路径长度：%d\n",0,pathlen);
			if(pathlen<minpathlen){
				minpathlen<pathlen;
				minpath=apath;
			}
		}
	}
	printf("起点为%d的最短路径\n",s);
	printf("最短路径长度：%d\n",minpathlen);
	printf("最短路径：");
	printf("0->");
	for(int i=0;i<minpath.size();i++){
		printf("%d->",minpath[i]);
	}
	cout<<"0"<<endl;
}
int main(){
	TSP(g,s);
}

2.分支限界法

#include"Graph.cpp"
#include<string.h>
#include<vector>
using namespace std;
int s;
MGraph g;
int Count=1;
vector<int>minpath;
int minpathlen=INF;

struct NodeType{
	int v,num;
	int visited[MAXV];
	int pathlen;
	vector<int>path;
	bool operator <(const NodeType &s) const{
		return pathlen>s.pathlen;
	}
};
void dispasolution(vector<int>path,int pathlen){
	cout<<Count++<<endl;
	for(int i=0;i<path.size();i++){
		printf("%2d",path[i]);
	}
	printf("路径长度",pathlen);
}
void TSP(){
	NodeType e,e1;
	priority_queue<NodeType>qu;
	e.v=0;
	e.pathlen=0;
	e.path.push_back(0);
	e.num=1;
	memset(e.visited,0,sizeof(e.visited));
	e.visited[0]=1;
	qu.push(e);
	while(!qu.empty()){
		e=qu.top();
		qu.pop();
		if(e.num==g.n){
			if(g.edges[e.v][s]!=0&&g.edges[e.v][s]!=INF){
				e.path.push_back(s);
				e.pathlen+=g.edges[e.v][s];
				dispasolution(e.path,e.pathlen);
				if(e.pathlen<minpathlen){
					minipathlen=e.pathlen;
					minpath=e.path;
				}
			}
		}else {
			for(int j=1;j<g.n;j++){
				if(g.edges[e.v][j]!=0&&g.edges[e.v][j]!=INF){
					if(e.visited[j]==1) continue;
					e1.v=j;
					e1.num=e.num+1;
					e1.path=e.path;
					e1.path.push_back(j);
					e1.pathlen=e.pathlen+g.edges[e.v][j];
					for(int j=0;j<g.n;j++){
						e1.visited[i]=e.visited[i];
					}
					if(e1.pathlen<minpathlen){
						e1.visited[j]=1;
						qu.push(e1);
					}
				}
			}	
		}
	}
}
int main(){
	TSP();
}

3.回溯法

void TSP(SET V,int i,vector<int>path,int pathlen){
	int prev;
	if(path.size()>0){
		prev=path.back();
	}
	path.push_back(i);
	pathlen+=g.edges[prev][i];
	if(V.size()==0) {
		if(g.edges[i][s]!=0&&g.edges[i][s]!=INF){
			path.push_back(0);
			pathlen+=g.edges[i][s];
			dispasolution(path,pathlen);
			if(pathlen<minpathlen){
				minpathlen=pathlen;
				minpath=path;
			}
		}
	}else {
		SET::iterator it;
		for(it=V.begin();it!=V.end();it++){
			SET tmpV=V;
			int j=*it;
			tmpV.erase(j);
			if(pathlen<minpathlen) 
				TSP(tmpV,j,path,pathlen);
		}
	}
}

4.贪心法

void TSP(MGraph g){
	int i,j,k;
	int minj,minedge;
	bool find;
	vector<int>minpath;
	int minpathlen=0;
	minpath.push_back(0);
	i=0;
	while(minpath.size()!=g.n){
		find=false;
		minedge=INF;
		for(j=1;j<g.n;j++){
			if(g.edges[i][j]!=0&&g.edges[i][j]!=INF){
				k=0;
				while(k<minpath.size()&&j!=minpath[k]){
					k=0;
					while(k<minpath.size()&&j!=minpath[k]) k++;
					if(k==minpath.size()){
						if(g.edges[i][j]<minedge){
							minedge=g.edges[i][j];
							minj=j;
						}
					}
				}
			}
		}
		minpath.push_back(minj);
		minpathlen+=minedge;
		i=minj;
	}
	minpath.push_back(0);
	minpathlen+=g.edges[minj][0];
	
}

5.动态规划法

typedef set<int>SET;
int s=0;
MGraph g;
int dp[1<<MAX][MAX];
int minpathlen;
vector<int>minpath;
void solve(){
	int n=g.n-1;
	memset(dp,0,sizeof(dp));
	for(int V=0;V<=(1<<n)-1;V++){
		for(int i=1;i<=n;i++){
			if(V&(1<<(i-1))){
				if(V==(1<<i-1)) dp[V][i]=edges[0][i];
				else {
					dp[V][i]=INF;
					for(int j=1;j<=n;j++){
						if(V&(1<<(j-1))&&i!=j){
							dp[V][i]=min(dp[V][i],dp[V^(1<<(i-1))][j]+g.edges[j][i]);
						}
					}
				}
			}
		}
	}
}