售货员的难题

Description

某乡有n个村庄（1< n < 20），有一个售货员，他要到各个村庄去售货，各村庄之间的路程s（0 < s < 1000）是已知的，且A村到B村与B村到A村的路大多不同。为了提高效率，他从商店出发到每个村庄一次，然后返回商店所在的村，假设商店所在的村庄为 1，他不知道选择什么样的路线才能使所走的路程最短。请你帮他选择一条最短的路。

Input

村庄数n和各村之间的路程（均是整数）。

Output

最短的路程

Sample Input

3 {村庄数}

0 2 1 {村庄1到各村的路程}

1 0 2 {村庄2到各村的路程}

2 1 0 {村庄3到各村的路程}

 

Sample Output

3

 

 

思路：如今有很多关于解TSP问题的算法，研究了几天，废寝忘食，发现TSP问题真的好难，主要是理解起来很容易，实现却很困难，时间复杂度为阶乘。

常用的也是易懂的，最简单的就是回溯法，其他还有分支限界法，NP完全性理论，近似算法（费用函数具有三角不等式性质时，可设计一个近似算法，而对于一般情况下的旅行商问题则不可能设计出具有常数性能比的近似算法，除非P=NP，略），网上还有一些其他的算法，我个人比较推荐模拟退火。

 

下面贴出最简单的回溯法

#include <iostream>
using namespace std;

#define MAX_VALUE 0xFFFFFF
int n;//定点数
int x[25];//当前解
int bestx[25];//当前最优解
int bestc;//当前最优值
int cc;//当前费用
int a[25][25];//图的邻接矩阵

void swap(int &a,int &b)
{
    int tep = a;
    a=b;
    b=tep;
}


void backtrack(int i)
{
    int j;
    if(i==n)
    {
        if(a[x[n-1]][x[n]]<MAX_VALUE&&a[x[n]][1]<MAX_VALUE&&(bestc==MAX_VALUE||cc+a[x[n-1]][x[n]]+a[x[n]][1]<bestc))
        {
            for(j=1;j<=n;j++)
                bestx[j]=x[j];
            bestc=cc+a[x[n-1]][x[n]]+a[x[n]][1];
        }
    }
    else
    {
        for(j=i;j<=n;j++)
            //是否可进入x[j]的子树？
            if(a[x[i-1]][x[j]]<MAX_VALUE&&(bestc==MAX_VALUE||cc+a[x[i-1]][x[j]]<bestc))
            {
                //搜索子树
                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]);
            }
    }

}

int tsp()
{
    int i;
    for(i=1;i<=n;i++)
        x[i]=i;
    bestc = MAX_VALUE;
    
    cc=0;
    //搜索x[2:n]的全排列
    backtrack(2);
    return bestc;
}

int main()
{
    int i,j,min;
    cin>>n;
    for(i=1;i<=n;i++)
    {
        for(j=1;j<=n;j++)
            cin>>a[i][j];
    }
    min = tsp();
    cout<<min<<endl;
    return 0;
}

以下贴出模拟退火的代码【转自  模拟退火算法——解决售货员的难题】

/*模拟退火*/
/*AC代码：0ms*/
#include <iostream>
#include <ctime>
#include <cstdlib>
using namespace std;
const int MAX=41;
const int RANN=1000;
const int RUNN=50;
const int INF=99999999;
int map[MAX][MAX],rpath[RANN][MAX],min[RANN],N;
void adjust(int x[],int rn)//rn为调整次数
{
    int a,b;
    while(rn--)
    {
        a=rand()%(N-1)+1;//调整的位置
        b=rand()%(N-1)+1;
        swap(x[a],x[b]);
    }
}
void get_map()
{
    int i,j;
    for(i=1;i<=N;i++)
        for(j=1;j<=N;j++)
            scanf("%d",&map[i][j]);
}
void get_rpath()//产生RANN组初始数列
{
    int i,j;
    for(i=0;i<RANN;i++)
    {
        for(j=1;j<=N-1;j++)
            rpath[i][j]=j+1;
        adjust(rpath[i],N-1);//初始调整
        min[i]=INF;
    }
}

void swap(int &x,int &y)//交换x,y
{
    int t=x;
    x=y;
    y=t;
}
int get_dis(int x[])//返回路径长度
{
    int sum=0,i,p=1;
    for(i=1;i<=N-1;i++)
    {
        sum+=map[p][x[i]];
        p=x[i];
    }
    sum+=map[p][1];
    return sum;
}
void numcpy(int x[],int y[])
{
    for(int i=1;i<=N-1;i++)
        x[i]=y[i]; 
}
void get_ans()
{
    int i,j,t=N-1,temp,p[41];
    while(t--)//调整的范围递减
    {
        for(i=0;i<RANN;i++)//遍历RanN组数据
        {
            for(j=0;j<RUNN;j++)//对于每组做RunN次
            {
                numcpy(p,rpath[i]);//因为每次都在原有的rpath[i]上改变
                adjust(p,t);
                temp=get_dis(p);
                if(temp<min[i])
                {
                    numcpy(rpath[i],p);//更新rpath[i];
                    min[i]=temp;
                }
            }
        }
    }
    int ans=min[0];
    for(i=1;i<RANN;i++)
        if(min[i]<ans)
            ans=min[i];
        printf("%d
",ans);
}
int main ()
{
    srand(time(0));//以时间为随机数种子产生随机数
    while(scanf("%d",&N)!=EOF)
    {
        get_map();
        get_rpath();
        get_ans();
    }
    return 0;
}