实现从武汉出发，进行34个省会的遍历，最后回到武汉，要求输出遍历路径和最后总里程

以下为贪心算法程序，回溯算法在最后，可是这两个算法都有缺点，特别是回溯算法，谁能帮我找出一个更好的算法啊。

/*********************************************************/

main.cpp

#include "setting.h"

 

int main (void){

      

       int** dist;

       char ch[10];

       dist= get ();                         //得到文件数据

      

       printf("请输入起点城市：");

       scanf("%s",ch);

       getdist(ch,dist);                    //得到遍历数据    

       return 0;

      

}

 

 

/*****************************************************************************/

operation.cpp  // 贪心算法

#include  "setting.h"

 

char city[40][10];

int cityNum = 0;

FILE* file = fopen ("distance.txt","r");

StringReader sr ;

char buf[20];

 

 

int getLine (FILE* file,char* str){

       static int c;

       int count = 0;

       int ifeof = 0;

       if (c == EOF){

              return -1;

       }

       while ((c=fgetc(file)) != EOF){

              if (c == '/n'){

                     str[count] = '/0';

                     return 1;

              }

             

              str[count++] = c;

       }

       str[count] = '/0';

       return 1;

}

 

int getToken (StringReader* sr,char* buf){

       int in = 0;

       char ch;

       int c = sr->offset;

       int k = 0;

       if (c == sr->len){

              return -1;

       }

    for (;c<sr->len;++c,sr->offset++){

                  ch=sr->str[c];

                     if (ch == '/t'||ch == ' '){

                            if (in == 1){

                                   buf[k] = '/0';

                                   return 1;

                            }           

                     }

                     else {

                            if (in == 0){

                                   in = 1;

                            }

                            buf[k++] = ch;

                     }

       }

       buf[k] = '/0';

       return 1;

}

 

void initStringReader (StringReader* sr){

       sr->len = strlen (sr->str);

       sr->offset = 0;

}

 

char* getCityName (int code){

       return city[code];

}

 

int getCityCode (char* cityName){

       for (int i = 0;i<cityNum;++i){

              if (strcmp(cityName,city[i]) == 0)

                     return i;

       }

       return -1;

}

 

void getData (int** dist){

       while ((getLine (file,sr.str))!=-1){

              initStringReader (&sr);

              getToken (&sr,buf);

              int code = getCityCode (buf);

              for (int i=0;i<cityNum;++i){

                     getToken(&sr,buf);

                     dist[i][code] = atoi(buf);

              }

       }

}

 

int** get(){

       getLine (file,sr.str);

       initStringReader (&sr);

       int i;

       int count = 0;

       while ((i = getToken (&sr,buf))!=-1){

              cityNum ++;

              int len = strlen (buf);

              for (int a=0;a<len;++a){

                     city[count][a] = buf[a];

              }

              city[count][a] = '/0';

              ++count;

       }

       int** dist =(int** )malloc ((sizeof (int*))*cityNum);

       for (i=0;i<cityNum;++i){

              dist[i] = (int*)malloc ((sizeof (int))*cityNum);

       }

       getData (dist);

 

       return dist;

      

}

/*****************************************************************************/

getdist.cpp                   

 

#include "setting.h"

 

void getdist(char ch[],int** dist)

{

       int s[M],dingwei[M];

    int n,number,u;

    int i,j,k,min,distance=0;

      

       getData (dist);

      

       system("cls");

 

              n=getCityCode(ch);

             

   

       u=1;

   number=n;

 

for(i=0;i<M;i++)

s[i]=0;

       for(j=0;j<M;j++)

       {

              for(i=0;i<M;i++)

                {

       

                     dingwei[i]=dist[number][i];

                }

                s[number]=1;       

      printf("%s->",getCityName(number));

                                                                            

                     min=MAX;                                                                                 

                     for(k=0;k<M;k++)                            

                     {

                       if(s[k]==0&&min>dingwei[k])  

                       {

                            min=dingwei[k];

                            number=k;

                       }

                       if(u==M)

                              min=dingwei[n];

                      

                     }

                     u++;

                                                

                    

                     distance+=min;

                    

                      

                    

       }

      

        printf("%s",getCityName(n));

        printf("/n距离为:%d/n",distance);

 

}/*****************************************************************************/

setting.h   // 一些头文件和函数接口

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define M 34

#define MAX 100000

typedef struct {

       char  str[1000];

       int len;

       int offset;

} StringReader;

 

int** get ();                     

void getdist(char ch[],int** dist);

int getCityCode (char* cityName);

char* getCityName (int code);

void  getData(int**dist);

/*****************************************************************************/

以下为 回溯算法

/********************************************************************************
#include "setting.h"

int x[34];
int v;
int bestV;
int bestX[34];
int n = 34;

int** dist;

void backtrack (int t,int** dist) {
 void swap(int a[], int i, int j);
  if (t > n - 1) {
   v += dist[0][x[n - 1]];
   if (v < bestV) {
    bestV = v;
    for (int i = 0; i < n; i++)
     bestX[i] = x[i];
   }
   printf("%d/n",v);
   v -= dist[0][x[n - 1]];
   return;
  }
 
 for (int i = t; i < n; i++) {
  
  swap(x, i, t);
  v += dist[x[t - 1]][x[t]];
  // 剪枝函数
  if (v < bestV)
   backtrack(t + 1,dist);
  v -= dist[x[t - 1]][x[t]];
  swap(x, i, t);
 }
}

void swap(int a[], int i, int j) {
 int temp = a[i];
 a[i] = a[j];
 a[j] = temp;
}

void getdist(int** dist){
 int i;
 for ( i = 0;i<n;++i){
  x[i] = i;
  bestX[i] = i;
 }
 v = 0;
 bestV = 99999;
  backtrack (1,dist);
 printf("%d/n",bestV);
 for (i = 0; i < n; i++)
  printf("%d/n",bestX[i]);

}