基於遺傳算法(Genetic Algorithm)的TSP問題求解(C)

 

基於遺傳算法的TSP問題求解(C)

 

　　TSP問題：

　　TSP(Travelling salesman problem): 譯作“旅行商問題”， 一個商人由於業務的需要，要到n個城市，每個城市之間都有一條路徑和其他所有的城市相連。現在要求從一個城市出發，穿越所有其他所有的城市，再回到出發的城市。 出於成本的考慮，要求商人走的路徑的長短最短。問能否找到這樣的一條路徑？

　　這是個經典的NP-complete問題。 時間復雜度為θ(n!)。 隨着城市的數量規模增大，在有限的時間內得不到問題的最優解。 我們只能退而求其次，在有限的時間內(或可接受的時間內)找到一個近似最優解，而且這個近似最優解和最優解的誤差我們也是可以接受的。 出於這樣的考慮，為求解這類問題的啟發式，元啟發式算法，演化算法營運而生。

　　隨着研究的深入，TSP問題已經演化成好多版本。本文的C程序對於對稱和非對稱的版本都適用。

　　遺傳算法：

　　遺傳算法(Genetic Algorithm)，也稱進化算法，是依據生物進化的過程而提出的一種啟發式算法，由美國的J.Holland於1975年首次提出。其主要特點是依據生物進化中的“優勝劣汰”或者“競爭”法作為問題的解的選擇依據。 直接對結構對象進行操作，不存在求導和函數連續性的限定；具有內在的隱並行性和更好的全局尋優能力；采用概率化的尋優方法，能自動獲取和指導優化的搜索空間，自適應地調整搜索方向，不需要確定的規則。遺傳算法的這些性質，已被人們廣泛地應用於組合優化、機器學習、信號處理、自適應控制和人工生命等領域。它是現代有關智能計算中的關鍵技術之一

　　遺傳算法的基本原理：

　　首先根據問題產生多個初始可行解()，然后從初始解中選擇諾干優異的個體(問題的解)進行各種操作(交叉，變異)用以產生新的后代。再從新的后代中選擇優異的個體進行相應的操作產生它們的后代，如此不斷循環，直到迭代的次數達到了預先設定的值或者多次迭代以后產生的最優異的個體(最優解)的質量並沒有明顯的提高，就可以停止迭代，這時的最優個體(最優解)最為問題的解。

　　從上面的原理我們可以知曉該算法主要涉及的步驟如圖 1所示：

• 編碼　　

　　在解實現初始化之前，如何表示一個解即編碼是一個很重要的問題。 一般的編碼方式有:

1. 基於二進制編碼: 作為遺傳算法傳統的編碼方式。對於TSP問題，經過交叉后可能得不到可行解，需要修補操作。
2. 基於矩陣的編碼: 需要更多的額外空間，而且隨着種群規模的增加，存儲空間劇增和前期處理工作任務很龐大。后續操作也比較復雜。
3. 基於鄰近的編碼: 采用鏈表的方式存儲,但是變異,交叉操作復雜
4. 基於格雷碼方法：傳統二進制編碼的一種改進，容易實現交叉，變異操作，但是對於該問題不是最優的
5. 基於符號編碼：對於TSP問題，我們直接使用路徑來表示一個染色體。即使用一個整數數組，數組長度為TSP城市的數量，數組中存儲各個城市編號，從下標為0開始逐個遍歷數組元素形成的一個序列即為路徑(對於要回到原點的要求，為了方便表示，在這里不作考慮，只是在計算路徑長度的時候會添加相應的長度)。

• 形成初始解

　　采用隨機的方式產生諾干個(種群規模)的序列，即產生符合城市編號的隨機數存儲在數組中，數組中的元素包含所有的城市編號，而且沒有重復的編碼。數組的個數為種群規模。

• 選擇

　　在形成一定數量的可行解（染色體）后，需要對這些父代的染色體進行篩選。根據生物遺傳的基因的優勝劣汰原則，在篩選染色體的我們也會秉承精英保留原則，使得優異的基因有更多的機會得到遺傳。

　　適應度函數： 這里我們選擇路徑長度的倒數來作為解的適應度

　　在這個問題中，我們選擇“輪盤賭”算法來篩選染色體。

　　基本原理：計算每個染色體(路徑)的長度的倒數，再得到所有路徑倒數之和，用每條路徑的倒數除以所有所有路徑倒數之和即為這條路徑被選中的概率(路徑越短，概率越高)。

• 交叉 

　　這里我們選擇交替位置交叉法（Alternating Position Crossover，APX）來對一對染色體進行交叉操作，其基本原理如下圖所示

　　左邊為父代的兩個染色體，右邊為子代染色體。 將左上的數組第一個元素放入右上數組的第一位置中，再轉移到左下數組第一個元素，查看右上數組是否已經包含了該元素，如果未包含將其插入右上數組中，否則插入右下數組中。接着從左上數組的第二個元素開始，到左下第二個元素，和前次同意的判斷操作。如此類推直到右邊兩個數組都被填滿了為止。

　　交叉概率：交叉概率對於解的收斂速度有着重要的影響。一般選擇0.6-1。

• 變異

　　生物的進化，除了遺傳父母的基因，還有自身基因有一定的概率突變。基於這個原理，變異操作在一定的概率上是作用於染色體自身的。

　　變異概率：一定的概率師兄自身基因的改變

　　在這個問題中，我們選擇位置倒換法，即染色體上隨機的產生兩個位置上數值互換。

• 終止條件

　　一般有兩種方式停止交叉，變異的操作。一，預先設定迭代次數。二，多次跌代后，解的質量得不到一定要求的提高，或者解達到要求的質量，這時都可以停止迭代。這個問題上我們選擇第一種。

　　

　　基於TSP問題的遺傳算法代碼如下：

　　

#include <stdio.h>
#include <tchar.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>


int scale; /* 種群規模 */
int cityNum; /* 城市數量 */
int *pathlength; /* 存儲種群每個個體路徑長度 */
double *cumPropa; /* 存儲個體累積概率 */
int bestlength; /* 最佳路徑長度 */
int *bestpath; /* 最佳路徑 */
float pc; /* 交叉概率 */
float pm; /* 變異概率 */
int count; /* 變異次數 */
int MAX_Gene; /* 迭代次數 */

/* 函數聲明 */
void APCrossover(int **,int ,int ,int );
void copy(int *,int **,int ,int );
void cumDistance(int **,int **, int *,int ,int );
void cumulatePro(int **,double *,int *,int );
void copytoBestPath(int *,int **,int ,int );
void copy(int *,int **,int ,int );
int *creatArray1(int );
double *creatArraydoub(int );
int **creatArray2(int , int );
void CrossAndMutation(int **,int );
void cumDistance(int **,int **, int *,int ,int);
void mutation(int **,int);
void Initialize(int **, int , int );
void readfile(int **, int , int );
void rouletteAlgo(int **,double *, int **,int );
void NcopyO(int **,int **);

//創建一個整形的二維整數數組
int **creatArray2(int scale, int cityNum)
{
    int i;

    int **ptemp;

    ptemp=(int **)malloc(sizeof(int *)*scale);
        for(i=0;i<scale;i++)
            ptemp[i]=(int *)malloc(sizeof(int)*cityNum);

    return ptemp;
}
//創建一個整形的一維數組
int *creatArray1(int scale)
{
    int *tempcreate;
    tempcreate=(int *)malloc(sizeof(int)*scale);
    return tempcreate;
}
//創建一個雙精度型的一維數組
double *creatArraydoub(int scale)
{
    double *tempcreate;
    tempcreate=(double *)malloc(sizeof(double)*scale);
    return tempcreate;
}

// 二維數組拷貝
void NcopyO(int **newgeneration,int **oldgeneratoin)
{
    int i,j;
    for(i=0;i<scale;i++)
        for(j=0;j<cityNum;j++)
            oldgeneratoin[i][j]=newgeneration[i][j];
            
}



//計算一次迭代各可行解的路徑長度
void cumDistance(int **oldgeneration,int **cityDistance, int *pathlength,int cityNum,int scale)
{
    int i,j,k;
    int length=0;
    int min=88888;
    int minp;

    for(i=0;i<scale;i++)
    {
        length=0;
        for(k=0;k<cityNum-1;k++)
        {
            j=k+1;
            length+=cityDistance[oldgeneration[i][k]][oldgeneration[i][j]];
        }
        //題目要求回到原點，所以加上回到原點的距離
        pathlength[i]=length+cityDistance[oldgeneration[i][cityNum-1]][oldgeneration[i][0]];

        if(pathlength[i]<min)
        {
            min=pathlength[i];
            minp=i;
        }
    }
    if(min<bestlength)
    {
        bestlength=min;
        //將每代最優解直接加入下一代中，即“精英保留”原則
        copytoBestPath(bestpath,oldgeneration,minp,cityNum);
    }

}




void copytoBestPath(int *bestpath,int **oldGeneration,int position,int cityNum)
{
    int i;
    for(i=0;i<cityNum;i++)
        bestpath[i]=oldGeneration[position][i];
}



//計算一次迭代中各個可行解作為交叉操作的累積概率

void cumulatePro(int **generation,double *cumPropa,int *pathlength,int scale)
{
    int i;
    double sumlength=0;

    for(i=0;i<scale;i++)
        sumlength+=1/(double)pathlength[i];

    cumPropa[0]=(1/(double)pathlength[0])/sumlength;

    for(i=1;i<scale;i++)
    {
        cumPropa[i]=(1/(double)pathlength[i])/sumlength+cumPropa[i-1];
    }
}


//初始化話生產相應規模的可行解
void Initialize(int **geneSolution, int scale, int cityNum)
{
    int i,j,k;
    int randnum;
    bool exist;

    srand(time(NULL));

    for(i=0;i<scale;i++)
        for(j=0;j<cityNum;j++)
        {
            exist=true;
            while(exist==true){
            //注意：rand()/Rand_MAX 結果只能是0， 應該先進行類型轉換
            randnum=(int)(((double)rand()/RAND_MAX)*cityNum);
                for(k=0;k<j;k++)
                    if(geneSolution[i][k]==randnum)
                        break;
                if(k==j)
                    exist=false;
            }
            geneSolution[i][j]=randnum;
        }

}

//讀取文件中的各相鄰點的距離信息
void readfile(int **cityDistance, int scale, int cityNum)
{
    int i,j;
    FILE *fp;
    errno_t err;

    err=fopen_s(&fp,"data.txt","r");

    if(err!=0)
    {
        printf("The file can not be found!\n");
    }
    else
    {
        
        for(i=0;i<scale;i++)
        {
            for(j=0;j<cityNum;j++)
            {        
                fscanf_s(fp,"%d ",&cityDistance[i][j]);
            }
        }
        


        fclose(fp);
    }

}

//拷貝一條路徑
void copy(int *oldGeneration,int **newGeneration,int position,int cityNum)
{
    int i;
    for(i=0;i<cityNum;i++)
        newGeneration[position][i]=oldGeneration[i];
}

//使用輪盤賭算法選擇交叉的對象
void rouletteAlgo(int **oldGeneration,double *cumPropa, int **newGeneration,int scale)
{
    int i,j;
    double randNum;

    for(i=0;i<scale-1;i++)
    {
        randNum=(double)rand()/RAND_MAX;
        if(cumPropa[0]>=randNum)
            copy(oldGeneration[0],newGeneration,i,scale);
        else
        {
            for(j=0;j<scale;j++)
                if(randNum>cumPropa[j] && randNum<=cumPropa[j])
                            break;
            copy(oldGeneration[i],newGeneration,i,scale);
        }
    }

    copy(bestpath,newGeneration,scale-1,scale);

}

//交叉操作：交替位置交叉法（Alternating Position Crossover，APX）
void APCrossover(int **newgeneration,int p1,int p2,int cityNum)
{
    int i;
    int s1=1;
    int s2=0;

    int *tempArray1;
    int *tempArray2;

    tempArray1=creatArray1(cityNum);
    tempArray2=creatArray1(cityNum);

    for(i=0;i<cityNum;i++)
    {
        tempArray1[i]=newgeneration[p1][i];
        tempArray2[i]=newgeneration[p2][i];
    }

    int m,n;
    m=1;
    n=0;
    
    while(s1<10 || s2<10)
    {
        for(i=0;i<s1;i++)
            if(tempArray1[m]==newgeneration[p1][i])
                break;
        if(i==s1)
        {
            newgeneration[p1][s1]=tempArray1[m];
            m++;
            s1++;
        }
        else{
            newgeneration[p2][s2]=tempArray1[m];
            m++;
            s2++;
        }


        for(i=0;i<s1;i++)
            if(tempArray2[n]==newgeneration[p2][i])
                break;
        if(i==s1)
        {
            newgeneration[p1][s1]=tempArray2[n];
            n++;
            s1++;
        }
        else{
            newgeneration[p2][s2]=tempArray2[n];
            n++;
            s2++;
        }
    }

}

//變異操作
void mutation(int **newgeneration,int p1)
{
    int rand1,rand2;
    int temp;
    int i;

    srand(time(NULL));

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

        rand1=(int)(((double)rand()/RAND_MAX)*cityNum);
        rand2=(int)(((double)rand()/RAND_MAX)*cityNum);
        while(rand1==rand2)
        {
            rand2=(int)(((double)rand()/RAND_MAX)*cityNum);
        }

        temp=newgeneration[p1][rand1];
        newgeneration[p1][rand1]=newgeneration[p1][rand2];
        newgeneration[p1][rand2]=temp;
    }

}

//對一代群體進行交叉變異操作
void CrossAndMutation(int **newgeneration,int cityNum)
{
    float rand1,rand2;
    int k;
    for(k=0;k<cityNum;k=k+2)
    {
        srand(time(NULL));
        rand1=(float)rand()/RAND_MAX;

        if(rand1>pc)
        {
            APCrossover(newgeneration,k,k+1,cityNum);
        }
        else
        {
            rand2=(float)rand()/RAND_MAX;
            if(rand2>pm)
            {
                mutation(newgeneration,k);
            }
            rand2=(float)rand()/RAND_MAX;
            if(rand2>pm)
            {
                mutation(newgeneration,k+1);
            }

        }
    }

}

int main()
{
    int **a;
    int **oldGeneration;
    int **newGeneration;
    int i,j;
    
    MAX_Gene=20;
    cityNum=10;
    scale=10;
    bestlength=888888;
    pc=0.6;
    pm=0.5;
    count=4;
    int m;


    a=creatArray2(scale,cityNum);
    pathlength=creatArray1(scale);
    cumPropa=creatArraydoub(scale);
    bestpath=creatArray1(cityNum);

    readfile(a,scale,cityNum);

    oldGeneration=creatArray2(scale,cityNum);
    newGeneration=creatArray2(scale,cityNum);

    Initialize(newGeneration,scale,cityNum);

    for(m=0;m<MAX_Gene;m++)
    {
        NcopyO(newGeneration,oldGeneration);
        cumDistance(oldGeneration,a,pathlength,scale,cityNum);
        cumulatePro(oldGeneration,cumPropa,pathlength,scale);
        rouletteAlgo(oldGeneration,cumPropa,newGeneration,scale);
        CrossAndMutation(newGeneration,cityNum);

    }

    printf("The best path is :\n");


    for(i=0;i<cityNum;i++)
    {
        printf("%d  ",bestpath[i]);
    }
    printf("\n");
    
    printf("The minmum length is %d\n",bestlength);
    
    return 0;
}

 　　遺傳算法只能得到問題的近似最優解，而且對不同的問題，該算法的性能也不一樣。一般要求結合問題的一些特點和屬性或者與其他的演化算法相結合，例如蟻群算法，粒子群算法，模擬退火法等。