遺傳算法解決旅行商問題(TSP)

這次的文章是以一份報告的形式貼上來，代碼只是簡單實現，難免有漏洞，比如循環輸入的控制條件，說是要求輸入1，只要輸入非0就行。希望會幫到以后的同學(*＾-＾*)

一、問題描述

   旅行商問題(Traveling-Salesman Problem,TSP)。設有n個互相可直達的城市，某推銷商准備從其中的A城出發，周游各城市一遍，最后又回到A城。要求為該旅行商規划一條最短的旅行路線。

二、目的

   為了解決旅行商問題，用了遺傳算法，模擬染色體的遺傳過程，進行求解。

   為了直觀的更有比較性的觀察到程序的運行效果，我這里程序里給定了10個城市的坐標，並計算出其任意兩個的歐氏距離，10個點的位置排布見圖1。程序的理想最優距離為20.485281，即繞三角形一圈，而且路程起點不固定，因為只要滿足點圍着三角形一圈即為最短距離，最優解。所以問題轉換為，求圖中10 個點的不重復點的閉環序列的距離最小值。

                   

                                       圖 1

三、原理

1、內部變量介紹 

程序總體圍繞了遺傳算法的三個主要步驟：選擇--復制，交叉，變異。給定了10個種群，即10條染色體，每條染色體都是除首位外不重復的點組成，首尾相同保證路線是閉合的，所以一條染色體包含11個點。

種群由一個結構體group表示，內含城市的序列int city[11]、種群的適應度double fit、該種群適應度占總群體適應度的比例double p，和為了應用賭輪選擇機制的積累概率 double jlleigailv。

程序還包括一個始終記錄所有種群中的最優解的城市序列數組groupbest[11]，記錄最優解的適應度，即最大適應度的變量 double groupbestfit。

種群的最大繁衍代數設置為1000，用戶能夠輸入繁衍代數，但必須在1000以內。10個點的不同排列序列有10！種，即3628800中排列可能，其中各代之間可能產生重復，不同種群間也會出現重復，學生覺得1000左右應該能驗證程序的性能了，就定為1000。

2、運行思想介紹

(a)采用整數編碼的方式，標記0到9號城市。

(b)選擇--復制：

利用賭輪選擇機制，分10次從10個種群中挑選出10個染色體進行復制。

每次隨機生成一個0到1之內的小數，因為適應度越高的染色體的積累概率區間越大，所以適應度越高的染色體被選擇的次數會越多，滿足了優勝劣汰的原則。

選擇--復制完后，要重新計算每個種群的適應度等信息，與已經保存的最優染色體進行比較，如果比已經存在的適應度還要高就進行最優染色體的更新。如果最優染色體沒有更新，則說明新成的最大適應度種群不如以前的好，則在新生成的種群中找到適應度最低的，用最優染色體提換掉。

(c)交叉：

    每一代的繁衍都讓10個種群中相鄰的兩個種群進行染色體交叉，交叉率為1，即0號種群和1號種群交叉，2號種群和3號種群交叉，以此類推。交叉段是由2個隨機數決定，采用部分映射交叉，直接交換由隨機數產生的染色體片段。

交叉完后因為要滿足點的不重復，所以要進行消除重復的操作。原理是用一個數組保留交叉過來的染色體片段，刪除染色體上已經交換的片段，在剩下的點中消除與新交換片段中重復的點，然后將原染色體剩下的點都向前移集中在頭部，再將保存在數組中的新交換過來的染色體插入到頭部之后，在以上過程中用一個數組記錄已經存在的點。接下來將沒有用的點順序插到染色體尾部，到此已經生成了新的染色體。

交叉完后要重新計算每個種群的適應度等信息，與已經保存的最優染色體進行比較，如果比已經存在的適應度還要高就進行最優染色體的更新。如果最優染色體沒有更新，則說明新成的最大適應度種群不如以前的好，則在新生成的種群中找到適應度最低的，用最優染色體提換掉。

(d)變異：

因為變異在自然界並不是每次都會發生，所有每次要盡行變異前都生成一個0到9內的隨機整數，如果大於3就進行變異，否則不變異，總體變異率為0.6。因為這個染色體和自然中的每一段都對應一個功能的染色體不一樣，染色體越是按數的相鄰大小排列，距離會越短，所以變異就起了很大作用，起到調整點的順序的作用，所以變異率要大一點。

如果要變異，則變異3次。每次生成2個隨機數，決定要在哪個種群變異哪一個位置。比如挑選了第二條染色體，變異第3個位置，則將染色體的3號位和6號位互換，即互換位置和為9。

(e)輸出：

輸出用戶程序得到的最優解的城市序列、路程距離、適應度和在第幾代得到的最優解。

程序可以循環多次運行，只要用戶按照提示輸入。

四、結果

    程序的總體結果又很大隨機性，但特別壞的結果畢竟只占少數，多數都是一般結果，多隨機運行幾次，還有控制繁衍的代數就能夠得到比較好的結果。令人振奮的是，經過多次的嘗試，又一次輸出了理想最優解，正好是圍三角形繞一圈，路程距離是20.485281，在第756代生成。一下是程序運行的比較好的結果、比較差的結果的舉例，和最優結果的貼圖，圖2為最優結果。

圖2

圖3

圖4

五、討論

這次程序--遺傳算法解決旅行商問題，的總體思想結合了課本和網上有關內容，但令人振奮的是，上圖1給的實例，還有具體的實現代碼和里面的具體思想都是出自學生仔細思考的結果，沒有抄襲，程序的每一步正確運行都凝聚了學生認真對待的心血。

寫這個程序總體上分成了2個步驟，思想理解與構造，具體代碼實現。

大約用了1個白天天左右的時間去了解：遺傳算法怎么去解決這個問題，怎樣進行選擇復制，交叉的方法有哪些，變異的方法又有哪些。決定了每一步用的思想后便進行具體敲代碼。

敲代碼又分成了兩段。第一段時間，在開始編碼的那天晚上我完成了程序的基本內容，跑一下也沒有問題，只是效果有很大隨機性，結果不是很好，第二天想了很久，又看了很多資料發現，原因在於交叉選擇的方法不好。一開始那種方法是，交換后的染色體直接放到相鄰染色體的相應位置，在其他地方進行消除重復的操作，染色體上會出現很多空洞，然后用沒有用過的點順序插在空洞里，構成新的染色體。后來我想了很久，吃飯時走在路上一想，不對啊，這樣有可能完全破壞了原來的優秀隊列，因為這個優秀染色體就是由排列順序決定的。回來后就修改了交叉的算法，形成了現在的算法，這樣能夠最大程度的保留原來的順序，又能很大可能獲得新的優秀隊列。

程序有400多行，交叉算法用的變量多而且又復雜，其中用來找bug的時間比較多，敲代碼的時候有很多細節問題腦子一開始想好了的，沒有敲上去。而且一邊敲，一邊也在對原由思想進行改進。

總之，遺傳算法的可移植性很大，可以用來逼近很多問題的最優解，實在是很厲害。做了這么多，我真的感覺收獲良多，一些細節處的bug好煩人，希望以后自己能夠更加細心。

六、代碼

里面的思想在前面已經講了，但里面的變量我設的時候標注的不是很清楚，思想懂了，代碼完全可以自己寫出來的(*＾-＾*)

#include<stdio.h>
#include<string.h>
#include<time.h>
#include<math.h>

double distance[10][11];//城市之間的距離 
int dai,die;
int cities[2][10];//記錄城市坐標
int citynum=10;
int groupbest[11];//最優解染色體 
double groupbestp;//最優解的p 
double groupbestfit;//最優解的fit 
int changebest;//要不要用最優解替代新種群 

struct group
{
  int city[11];//一維記錄城市序號，二三維記錄坐標
  double p;//占總群的概率 
  double fit;//適應度 
  double jileigailv;
}group[10];

/*用來計算種群的p、fit*/
void jisuan() 
{
  int i,j,k;
  double ss,s;
  s=0.0;
  ss=0.0;
  for(k=0;k<10;k++)
  {
    for(i=0;i<citynum;i++)
        {
          s+=distance[group[k].city[i]][group[k].city[i+1]];
        }
    group[k].fit=1.0/s;
    ss+=group[k].fit;
  }
  s=0.0;
  for(i=0;i<10;i++)
  {
  group[i].p=group[i].fit/ss;
  s+=group[i].p;
  group[i].jileigailv=s;
  } 
}
/*保存最優解*/ 
void savebest()
{
  int i,j,flag=0;
  double fit=groupbestfit;
  j=0;
  for(i=0;i<10;i++)
  {
     if(group[i].fit>fit)
     {
       j=i;
       fit=group[i].fit;
       flag=1;//標記已經有更好的 
     }
  }
     if(flag)
     {
         dai=die;
       for(i=0;i<citynum+1;i++)//保存最優解
       {
          groupbest[i]=group[j].city[i];
       }
       groupbestp=group[j].p;
       changebest=0; 
       groupbestfit=group[j].fit;
     }
     else
      changebest=1;//說明新生成的解還不如原來的好，要進行替換
}
/*用最優解替代新種群中的最差的染色體*/
void changebestgroup()
{
  int j,i;
  double fit=group[0].fit;
  j=0;
  if(changebest)
  {
    for(i=1;i<10;i++)
    {
      if(group[i].fit<fit)
      {
        fit=group[i].fit;
        j=i;
      }
    }
    for(i=0;i<citynum+1;i++)
    {
      group[j].city[i]=groupbest[i];
    }
    jisuan();
  }
}
/*初始種群和城市坐標，計算距離*/ 
void chushigroup()
{
  int i,j,t,flag,k;
  double ss;
  cities[0][0]=0;//初始化坐標
  cities[1][0]=0;
  cities[0][1]=2;
  cities[1][1]=0;
  cities[0][2]=4;
  cities[1][2]=0;
  cities[0][3]=6;
  cities[1][3]=0;
  cities[0][4]=6;
  cities[1][4]=2;
  cities[0][5]=6;
  cities[1][5]=4;
  cities[0][6]=6;
  cities[1][6]=6;
  cities[0][7]=5;
  cities[1][7]=5;
  cities[0][8]=4;
  cities[1][8]=4;
  cities[0][9]=2;
  cities[1][9]=2;
memset(groupbest,-1,sizeof(groupbest));
groupbestp=0.0;
groupbestfit=0.0;
changebest=0;
  for(i=0;i<citynum;i++)
    for(j=0;j<=i;j++)
    {
      if(j==i)
          distance[i][j]=0.0;
      else
      {
          distance[i][j]=sqrt(pow(cities[0][i]-cities[0][j],2.0)+pow(cities[1][i]-cities[1][j],2.0));//歐氏距離
          distance[j][i]=distance[i][j];
      }
    }
  printf("最優解的距離是：%f\n",distance[0][1]+distance[1][2]+distance[2][3]+distance[3][4]+distance[4][5]+distance[5][6]+distance[6][7]+distance[7][8]+distance[8][9]+distance[9][0]);
  srand((unsigned)time(NULL));
  ss=0;
  for(k=0;k<10;k++)
  {//一個數量為10的種群，和10 個城市環 
    for(i=0;i<citynum;i++)
    {
        flag=1;
        while(flag)
        {
          t=rand()%citynum;
           for(j=0;j<i;j++)
          {
            if(group[k].city[j]==t)
            {
              break;
            }
          }
            if(j==i)
            {
              group[k].city[i]=t;
              flag=0;
            }
         }
     }
   group[k].city[10]= group[k].city[0];
  }
  //以上產生了10 個種群，分別有不重復的染色體

jisuan();
savebest();
printf("初始種群為：\n");
for(i=0;i<10;i++)
{
  for(j=0;j<citynum+1;j++)
      printf("%d ",group[i].city[j]);
  printf("||適應度：%f，占總群的概率：%f\n",group[i].fit,group[i].p);
}
}
/*選擇--復制*/ 
void xuanze()
{
  int i,j,temp[10][11],k;
  double t;
  srand((unsigned)time(NULL));
  for(i=0;i<10;i++) //選10條染色體出來復制,賭輪
  {
    t=rand()%10000*1.0/10000;
    for(j=0;j<10;j++)
    {
        
      if(t<=group[j].jileigailv)
      {
          for(k=0;k<citynum+1;k++)
          {
            temp[i][k]=group[j].city[k];
          }
          break; 
      } 
    }
  }
  //拷貝新種群
  for(i=0;i<10;i++)
    for(j=0;j<citynum+1;j++)
    {
      group[i].city[j]=temp[i][j];
    }
    jisuan();
    savebest();
    changebestgroup();
}
/*交叉*/ 
void jiaocha()
{
  int point1,point2,temp,i,j,k,temp3[2][10],temp2[2][10],num,write;
  srand((unsigned)time(NULL));
  point1=rand()%10;
  point2=rand()%10;
  if(point1>point2)
  {
    temp=point1;
    point1=point2;
    point2=temp;
  }
  //交換,每2條交換
 if(point1!=point2)
 {
  for(j=1;j<10;j=j+2)
  {
       memset(temp3,-1,sizeof(temp3));
       memset(temp2,-1,sizeof(temp2));
       k=0;
    for(i=point1;i<=point2;i++)
    {
     temp2[0][k]=group[j].city[i];
     temp2[1][k]=group[j-1].city[i];
     temp3[0][temp2[0][k]]=1;//標記數字已經存在了
     temp3[1][temp2[1][k]]=1;
     k++;
     group[j].city[i]=-1;
     group[j-1].city[i]=-1;
    }
    num=point2-point1+1;//交換的位數 
     //消重
    for(k=0;k<point1;k++)
      {
        if(temp3[0][group[j-1].city[k]]==1)
        {
           group[j-1].city[k]=-1;
        }
        else
           temp3[0][group[j-1].city[k]]=1;
      } 
      for(k=point2+1;k<citynum;k++)
      {
        if(temp3[0][group[j-1].city[k]]==1)
        {
           group[j-1].city[k]=-1;
        }
        else
           temp3[0][group[j-1].city[k]]=1;
      }
      for(k=0;k<point1;k++)
      {
        if(temp3[1][group[j].city[k]]==1)
        {
           group[j].city[k]=-1;
        }
        else
           temp3[1][group[j].city[k]]=1;
      } 
      for(k=point2+1;k<citynum;k++)
      {
        if(temp3[1][group[j].city[k]]==1)
        {
           group[j].city[k]=-1;
        }
        else
           temp3[1][group[j].city[k]]=1;
      }
      write=0; 
      for(i=0;i<10;i++)
      {
      while(write<10&&group[j-1].city[write]==-1)
      {
        write++;
      }
      if(write<10)
      {
        temp=group[j-1].city[i];
        group[j-1].city[i]=group[j-1].city[write];
        group[j-1].city[write]=temp;
        write++;
      }
      else
      {
          write=0;
      for(k=i;k<10;k++)
      {
          group[j-1].city[k]=temp2[0][write++];
          if(write==num)
          break;
       }
      break;
      }
    } 
     write=0; 
     for(i=0;i<10;i++)
     {
      while(write<10&&group[j].city[write]==-1)
      {
        write++;
      }
      if(write<10)
      {
        temp=group[j].city[i];
        group[j].city[i]=group[j].city[write];
        group[j].city[write]=temp;
        write++;
      }
      else
      {
          write=0;
        for(k=i;k<10;k++)
        {
          group[j].city[k]=temp2[1][write++];
          if(write==num)
              break;
         }
        break;
      }
    } 
    k=0;
    for(i=0;i<citynum;i++)
    {
       if(group[j-1].city[i]==-1)
       {
         while(temp3[0][k]==1&&k<10)
         {
           k++;
         }
         group[j-1].city[i]=k++;
       }
    }
    k=0;
    for(i=0;i<citynum;i++)
    {
       if(group[j].city[i]==-1)
       {
         while(temp3[1][k]==1&&k<10)
         {
           k++;
         }
         group[j].city[i]=k++;
       }
    }
   group[j].city[10]=group[j].city[0];
   group[j-1].city[10]=group[j-1].city[0];
  }//end of j
 jisuan();
 savebest();
 changebestgroup();
 } //end of if(!)
}
/*變異*/ 
void bianyi()
{
   int t1,t2,temp,t,s=3;
   srand((unsigned)time(NULL));
   t=rand()%10;
   if(t>3)//變異率為3/5 
   {
       //挑1個不同的變異，只交換一位
    t1=rand()%10;//種群 
    t2=rand()%10;//變換位
    temp=group[t1].city[t2];
    group[t1].city[t2]=group[t1].city[9-t2];
    group[t1].city[9-t2]=temp;
    group[t1].city[10]=group[t1].city[0];   
   }
   jisuan();
   savebest();
   changebestgroup();
}
/*主函數*/
int  main()//最優解20.485281
{
  int j,flag,tuichu=1;
  double distancenum;
  while(tuichu)
  {
    distancenum=0.0;
    flag=1;
    chushigroup();
    while(flag)
    {
    printf("請輸入種群繁衍代數（1000以內）：");
    scanf("%d",&die);
    if(die<=1000)
    {
    flag=0;
    }
  }
  while(die--)
  {
     xuanze();
     jiaocha();
     bianyi();
  }
 printf("最優種群是：\n");
      for(j=0;j<citynum+1;j++)
      {
        printf("%d ",groupbest[j]);
        if(j<citynum)
        {
        distancenum+=distance[groupbest[j]][groupbest[j+1]];
        }
      }
      printf("距離為:%f,適應度為：%f,代數：%d\n\n",distancenum,groupbestfit,dai);
      printf("繼續產生新種群請按輸入1，退出請輸入0：");
      scanf("%d",&tuichu); 
      printf("\n");
    }
      return 0;
}