TSP_遗传算法求解

head.h

#define N 10



class Generation

{

public:

    int state[4][N+1];//染色体---种群规模为4,有10个城市

    float loadlength[4];//染色体的路径长度

    float Fitness[4];//适应度

    float SPro[4];//选择概率

    float AcPro[4];//累积概率

    int ChoiceNum[4];//选择次数

  

    Generation()

    {

        int i;

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

            for(int j=0;j<N+1;j++)

                state[i][j]=-1;

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

        {

            loadlength[i]=0;

            Fitness[i]=0;

            SPro[i]=0;

            AcPro[i]=0;

            ChoiceNum[i]=0;

        }

    }  

};

class Point

{

public:

    int x;

    int y;

    Point(int a,int b)

    {

        x=a; 

        y=b; 

    }

};



void RAND(double *r);

Generation Init(Generation G);//初始化群体

void count_distance();//计算各个城市之间的直线距离

float count_loadlegth(Generation* G);//计算路径长度

void count_fitness(Generation* G);//计算适应度 

void count_pro(Generation* G);//计算选择概率和累计概率

void count_choiceNum(Generation* G);//计算被选中的次数

void addtoopen(Generation G);

void Copy_Generation(Generation* G1,Generation G0);//根据被选中次数复制上一代染色体

void Variation(Generation *G1);

void Cross(Generation *G1);

 

Main.cpp

#include<iostream>

#include"head.h"

using namespace std;

#define N 10



Generation OPEN[5000];//队列-----(数据保护)每一代各染色体的情况

int OPhead=0,OPtail=0,openlen=5000;

float Distance[N][N]={0};//存储各个城市之间的直线距离

float MinShort=3000;//最短路径长度

int MinShortLoad[N+1]={0};//最短路径



int main()

{

    int i;

    //计算各个城市之间的直线距离

    count_distance();    

    

    Generation G0,G1;

    G0=Init(G0);//初始种群 

    G1=G0;

    int GNUM=0;

    while(MinShort>167)

    {

        G0=G1;

        printf("第%d代染色体情况:\n",GNUM);

        count_loadlegth(&G0);//计算路径长度        

        printf("已搜索到的路径中最短为: %f\n",MinShort);

        printf("已搜索到的路径中最短路径: ");

        for(i=0;i<N+1;i++)

            printf("%d ",MinShortLoad[i]);

        printf("\n");



        count_fitness(&G0);//计算适应度        

        count_pro(&G0);    //计算选择概率和累计概率        

        count_choiceNum(&G0);//计算被选中的次数

        addtoopen(G0);//保护每一代的记录

     



        printf("下一代:\n");

        //复制

        printf("复制后:\n");    

        Copy_Generation(&G1,G0);//根据被选中次数复制上一代染色体G0

        //交叉

        printf("交叉后:\n");

        Cross(&G1);///////////

        //变异    

        if(GNUM%5==0)//每5代(20条染色体)里变异一次(约0.5条染色体变异)-----变异率2.5%

        {

            printf("变异后:\n");

            Variation(&G1);    

        }



        printf("\n\n");

        GNUM++;

    }

    return 0;    

}

 

Function.cpp

#include<iostream>

#include<stdlib.h>//for rand(),srand()

#include<time.h> //for time()

#include<math.h>

#include<string.h>

#include"head.h"

#define N 10



extern Generation OPEN[5000];//队列-----(数据保护)每一代各染色体的情况

extern int OPhead,OPtail,openlen;

extern float Distance[N][N];//存储各个城市之间的直线距离

extern float MinShort;//最短路径长度

extern int MinShortLoad[N+1];//最短路径





void count_distance()

{

    //各个城市的位置坐标

    Point Position[N]={ Point(87,7),Point(91,38),Point(83,46),Point(71,44),Point(64,60),

                        Point(68,58),Point(83,69),Point(87,76),Point(74,78),Point(71,71)

                        //Point(58,69),Point(54,62),Point(51,67),Point(37,84),Point(41,94),

                        //Point(2,99),Point(7,64),Point(22,60)//,Point(25,62),Point(18,54)

                        //Point(4,50),Point(13,40),Point(18,40),Point(24,42),Point(25,38),

                        //Point(41,26),Point(45,21),Point(44,35),Point(58,35),Point(62,32)

                        };



    int i,j;  

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

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

            Distance[i][j]=sqrt(pow(Position[i].x-Position[j].x,2)+pow(Position[i].y-Position[j].y,2)); 

}

Generation Init(Generation G)

{

    int i,j;

    int Arr[4][N+1]={0};

    /*={{7,8,9,4,5,6,1,2,3,0,7},//

        {9,8,7,3,2,1,6,5,4,0,9},//

        {1,3,5,7,9,2,4,6,8,0,1},//

        {0,1,2,3,4,5,6,7,8,9,0}};// //初始四条路径*/

    for(i=0;i<4;i++)//产生随机初始种群

    {

        for(j=0;j<N;j++)//j---已经得到的序列个数

        {

            int temp=rand()%N;

            for(int t=0;t<j ;t++)

                if(temp==Arr[i][t])

                { temp=rand()%N;  t=-1;  }



            Arr[i][j]=temp;

        }

        Arr[i][N]=Arr[i][0];

    }



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

        for(j=0;j<N+1;j++)

             G.state[i][j]=Arr[i][j];//初始化第0代的的种群状态

    return G;    

}

float count_loadlegth(Generation* G)//计算路径长度

{

    int i,j;

    float Short=10000.0;

    int Snum;

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

    {

        float DistanceAdd=0.0;

        for(j=0;j<N;j++)//11-1

        {

            int c1=(*G).state[i][j];

            int c2=(*G).state[i][j+1];

            DistanceAdd += Distance[c1][c2];

        }

        (*G).loadlength[i]=DistanceAdd;

        if(DistanceAdd<Short)  

        {    Short=DistanceAdd ;  Snum=i;  } 

    }

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

    {

        for(j=0;j<N+1;j++)

            printf("%d ",(*G).state[i][j]);

        printf("   ----路径长: %f\n",(*G).loadlength[i]);

    }



    printf("最短路径为:  ");

    for(j=0;j<N+1;j++)    

        printf("%d  ",(*G).state[Snum][j]);

    printf("\n最短路径长: ---%f\n",Short);//输出当代最短路径

    if(Short<MinShort)//获取全局最短路径长度及其最短路径

    {

        MinShort=Short;

        for(j=0;j<N+1;j++)

            MinShortLoad[j]=(*G).state[Snum][j];

    }



    return Short;//返回当代最短路径

}

void count_fitness(Generation* G)//计算适应度

{

    for(int i=0;i<4;i++)

        (*G).Fitness[i]=(float)1000/(*G).loadlength[i];//计算得每个染色体的适应度((float)10000用于调整数值)

}

void count_pro(Generation* G)//计算选择概率和累计概率    

{

    int i;

    float ALL_fitness=(*G).Fitness[0]+(*G).Fitness[1]+(*G).Fitness[2]+(*G).Fitness[3];

    for(i=0;i<4;i++)//选择概率

        (*G).SPro[i]=(*G).Fitness[i]/ALL_fitness;



    for(i=0;i<4;i++)//累计概率

    {

        if(i==0) (*G).AcPro[i]=(*G).SPro[i];

        else     (*G).AcPro[i]=(*G).SPro[i]+(*G).AcPro[i-1];

    }

}

void RAND(double *r)//产生随机数

{

    //获得当前的时间作为随机数的种子//seed=time(0)

    srand(time(0));//两次获取随机数时间之差大于1s产生的随机数才会不同

    int i;

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

    {

        r[i]=(double)rand()/(double)RAND_MAX;//RAND_MAX=32767

    }

}

void count_choiceNum(Generation* G)//计算被选中的次数

{

    //产生随机数

    double r[4]={0.0};

    RAND(&r[0]);    



    int i,j;

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

        for(j=0;j<4;j++)//对于每一个随机概率

        {

            if(i==0)

            {    

                if(r[j]<(*G).AcPro[i])

                    (*G).ChoiceNum[i]++;

            }

            else

            {

                if(r[j]>=(*G).AcPro[i-1] && r[j]<(*G).AcPro[i] )

                    (*G).ChoiceNum[i]++;

            }

        }

    printf("被选中的次数: ");

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

        printf("%d ",(*G).ChoiceNum[i]);

    printf("\n");

}

void addtoopen(Generation G)

{

    OPEN[OPtail++]=G; //向尾部添加节点 

    OPtail = OPtail%openlen;

}

 

Cross.cpp(交叉)

#include<iostream>

#include<stdlib.h>//for rand(),srand()

#include<time.h> //for time()

#include"head.h"

#define N 10



extern Generation OPEN[5000];//队列-----(数据保护)每一代各染色体的情况

extern int OPhead,OPtail,openlen;

extern float Distance[N][N];//存储各个城市之间的直线距离





//交叉

void Cross(Generation *G1)

{

    int i;

    char OffSpr_A[N+1]={0},OffSpr_B[N+1]={0}, OffSpr_C[N+1]={0},OffSpr_D[N+1]={0};//记录交叉序列

    int kk;



    //*****获取1、2号后的交叉**************************//

    Generation Gt=*G1;//保护G1

    int C=rand()%N;//获取随机城市代号

    //int CV=C;//保护C

    OffSpr_A[0]=C;//将城市C加入记录---第1个子孙

    int count=N;//对前10个基因进行交叉（最后一个是重复的城市）

    kk=1;

    while(count!=1)

    {

        int Ra,Rb;

        for(i=0;i<N;i++)//求城市C在Gt.state[0][]、Gt.state[1][]中的下标位置

        {    

            if(Gt.state[0][i]==C)  Ra=i;//记录下标    

            if(Gt.state[1][i]==C)  Rb=i;

        }

        //printf("随机起始城市: %d---下标: %d %d  ",C,Ra,Rb);        

        int Cright_A,Cright_B;

        for(i=(Ra+1)%N; ;)/////////寻找C在G1.state[0][]中的右城市号

        {

            if(Gt.state[0][i]!=-1)

            {    Cright_A=Gt.state[0][i];  break;  }

            i=(i+1)%N;

        }

        //printf("右城市A:%d  ",Cright_A);

        for(i=(Rb+1)%N; ;)/////////寻找C在G1.state[1][]中的右城市号

        {

            if(Gt.state[1][i]!=-1)

            {   Cright_B=Gt.state[1][i];  break;  }

            i=(i+1)%N;

        }

        //printf("右城市B:%d\n",Cright_B);



        float da,db;

        da=Distance[C][Cright_A];

        db=Distance[C][Cright_B];

        if(da<=db) 

        {    

            OffSpr_A[kk++]=Cright_A;//加入记录        

            C=Cright_A;

        }else

        {

            OffSpr_A[kk++]=Cright_B;            

            C=Cright_B;

        }

        Gt.state[0][Ra]=-1;//删除城市G1.state[0][Ra]---标记为-1

        Gt.state[1][Rb]=-1;



        count--;

    }

    OffSpr_A[N]=OffSpr_A[0];//最后一个城市与第一个城市相同

    



    Gt=*G1;//保护G1

    //C=CV;

    C=rand()%N;//获取随机城市代号

    OffSpr_B[0]=C;//第2个子孙

    count=N;

    kk=1;

    while(count!=1)

    {

        int Ra,Rb;

        for(i=0;i<N;i++)//求城市C在Gt.state[0][]、Gt.state[1][]中的下标位置

        {    

            if(Gt.state[0][i]==C)  Ra=i;//记录下标    

            if(Gt.state[1][i]==C)  Rb=i;

        }

        //printf("随机起始城市: %d---%d %d  ",C,Ra,Rb);        

        int Cleft_A,Cleft_B;

        for(i=(Ra-1+N)%N; ;)/////////寻找C在G1.state[0][]中的左城市号

        {

            if(Gt.state[0][i]!=-1)

            {    Cleft_A=Gt.state[0][i];  break;  }

            i=(i-1+N)%N;

        }

        //printf("右城市A:%d  ",Cleft_A);

        for(i=(Rb-1+N)%N; ;)/////////寻找C在G1.state[1][]中的左城市号

        {

            if(Gt.state[1][i]!=-1)

            {   Cleft_B=Gt.state[1][i];  break;  }

            i=(i-1+N)%N;

        }

        //printf("右城市B:%d\n",Cleft_B);



        float da,db;

        da=Distance[C][Cleft_A];

        db=Distance[C][Cleft_B];

        if(da<=db) 

        {    

            OffSpr_B[kk++]=Cleft_A;//加入记录    

            C=Cleft_A;

        }else

        {

            OffSpr_B[kk++]=Cleft_B;

            C=Cleft_B;

        }

        Gt.state[0][Ra]=-1;//删除城市G1.state[0][Ra]---标记为-1

        Gt.state[1][Rb]=-1;



        count--;

    }

    OffSpr_B[N]=OffSpr_B[0];//最后一个城市与第一个城市相同

    //////////////////////////////////////////////////////







    //*****获取3、4号后代的交叉**************************//

    Gt=*G1;//保护G1

    C=rand()%N;//获取随机城市代号

    //CV=C;//保护C

    OffSpr_C[0]=C;//将城市C加入记录---第3个子孙

    count=N;

    kk=1;

    while(count!=1)

    {

        int Ra,Rb;

        for(i=0;i<N;i++)//求城市C在Gt.state[0][]、Gt.state[1][]中的下标位置

        {    

            if(Gt.state[2][i]==C)  Ra=i;//记录下标    

            if(Gt.state[3][i]==C)  Rb=i;

        }

        //printf("随机起始城市: %d---%d %d  ",C,Ra,Rb);        

        int Cright_A,Cright_B;

        for(i=(Ra+1)%N; ;)/////////寻找C在G1.state[0][]中的右城市号

        {

            if(Gt.state[2][i]!=-1)

            {    Cright_A=Gt.state[2][i];  break;  }

            i=(i+1)%N;

        }

        //printf("右城市A:%d  ",Cright_A);

        for(i=(Rb+1)%N; ;)/////////寻找C在G1.state[1][]中的右城市号

        {

            if(Gt.state[3][i]!=-1)

            {   Cright_B=Gt.state[3][i];  break;  }

            i=(i+1)%N;

        }

        //printf("右城市B:%d\n",Cright_B);



        float da,db;

        da=Distance[C][Cright_A];

        db=Distance[C][Cright_B];

        if(da<=db) 

        {    

            OffSpr_C[kk++]=Cright_A;//加入记录        

            C=Cright_A;

        }else

        {

            OffSpr_C[kk++]=Cright_B;

            C=Cright_B;

        }

        Gt.state[2][Ra]=-1;//删除城市G1.state[0][Ra]---标记为-1

        Gt.state[3][Rb]=-1;



        count--;

    }

    OffSpr_C[N]=OffSpr_C[0];//最后一个城市与第一个城市相同





    Gt=*G1;//保护G1

    //C=CV;

    C=rand()%N;//获取随机城市代号

    OffSpr_D[0]=C;//第4个子孙

    count=N;    

    kk=1;

    while(count!=1)

    {

        int Ra,Rb;

        for(i=0;i<N;i++)//求城市C在Gt.state[0][]、Gt.state[1][]中的下标位置

        {    

            if(Gt.state[2][i]==C)  Ra=i;//记录下标    

            if(Gt.state[3][i]==C)  Rb=i;

        }

        //printf("随机起始城市: %d---%d %d  ",C,Ra,Rb);        

        int Cleft_A,Cleft_B;

        for(i=(Ra-1+N)%N; ;)/////////寻找C在G1.state[0][]中的左城市号

        {

            if(Gt.state[2][i]!=-1)

            {    Cleft_A=Gt.state[2][i];  break;  }

            i=(i-1+N)%N;

        }

        //printf("右城市A:%d  ",Cleft_A);

        for(i=(Rb-1+N)%N; ;)/////////寻找C在G1.state[1][]中的左城市号

        {

            if(Gt.state[3][i]!=-1)

            {   Cleft_B=Gt.state[3][i];  break;  }

            i=(i-1+N)%N;

        }

        //printf("右城市B:%d\n",Cleft_B);



        float da,db;

        da=Distance[C][Cleft_A];

        db=Distance[C][Cleft_B];

        if(da<=db) 

        {    

            OffSpr_D[kk++]=Cleft_A;//加入记录            

            C=Cleft_A;

        }else

        {

            OffSpr_D[kk++]=Cleft_B;            

            C=Cleft_B;

        }

        Gt.state[2][Ra]=-1;//删除城市G1.state[0][Ra]---标记为-1

        Gt.state[3][Rb]=-1;



        count--;

    }

    OffSpr_D[N]=OffSpr_D[0];//最后一个城市与第一个城市相同

    //////////////////////////////////////////////





    

    for(i=0;i<N+1;i++)//将交叉得到的序列复制回G1

        (*G1).state[0][i]=OffSpr_A[i];

    for(i=0;i<N+1;i++)

        (*G1).state[1][i]=OffSpr_B[i];

    for(i=0;i<N+1;i++)

        (*G1).state[2][i]=OffSpr_C[i];

    for(i=0;i<N+1;i++)

        (*G1).state[3][i]=OffSpr_D[i];



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

    {    

        for(int j=0;j<N+1;j++)

            printf("%d ",(*G1).state[i][j]);

        printf("\n");

    }



}

 

Copy_Variation.cpp(复制和变异)

#include<iostream>

#include<stdlib.h>//for rand(),srand()

#include<time.h> //for time()

#include<math.h>

#include<string.h>

#include"head.h"

#define N 10



extern Generation OPEN[5000];//队列-----(数据保护)每一代各染色体的情况

extern int OPhead,OPtail,openlen;

extern float Distance[N][N];//存储各个城市之间的直线距离

extern float MinShort;//最短路径长度

extern int MinShortLoad[N+1];//最短路径



void Copy_Generation(Generation* G1,Generation G0)//根据被选中次数复制上一代染色体G0

{    

    int i,j;

    int k=0;

    float maxloadlen=0;//选取路径最长的用MinShortLoad[]替换

    int maxindex;

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

        if(G0.loadlength[i]>maxloadlen)

        {

            maxloadlen=G0.loadlength[i];

            maxindex=i;//记录最长路径下标

        }

    for(j=0;j<N+1;j++)

        G0.state[i][j]=MinShortLoad[j];//替换最长的路径为搜索过的最短路径



    for(i=0;i<4;i++)//对于G0的每一个染色体

        for(j=0;j<G0.ChoiceNum[i];j++)//根据被选中次数复制G0染色体

        {

            for(int t=0;t<N+1;t++)

                (*G1).state[k][t]=G0.state[i][t];

            k++;

        }

    

    for(i=0;i<3;i++)//交换子染色体的位置（减少相同染色体相邻）

    {

        for(int k=0;k<N+1;k++) 

            if((*G1).state[i][k]!=(*G1).state[i+1][k])//判断第[i]个和第[i+1]个是否相同

                break;

        if(k==N+1)//相邻染色体相同

        {

            char temp[N+1]={0};        

            for(j=0;j<N+1;j++)  temp[j]=(*G1).state[i+1][j];

            for(j=0;j<N+1;j++)  (*G1).state[i+1][j]=(*G1).state[(i+2)%4][j];

            for(j=0;j<N+1;j++)  (*G1).state[(i+2)%4][j]=temp[j];

        }

    }



    for(i=0;i<4;i++)//输出复制后的情况

    {    

        for(j=0;j<N+1;j++)

            printf("%d ",(*G1).state[i][j]);

        printf("\n");

    }

} 











void Variation(Generation *G1)

{

        int i,j;



        int k=rand()%4;//取其中一条进行变异

        int R=rand()%N;//产生随机起始城市下标

        //printf("%d %d\n",k,R);

        //printf("随机起始城市: %d\n",(*G1).state[k][R]);



        float D=10000;

        int City=0;

        for(i=0;i<N;i++)//寻找距离起始城市最近的非邻城市

        {

            if(i!=(*G1).state[k][R] && i!=(*G1).state[k][(R-1+N)%N] && i!=(*G1).state[k][(R+1)%N])

                if(Distance[ (*G1).state[k][R] ][i]<D)

                {

                    D=Distance[ (*G1).state[k][R] ][i];//取离城市G1.state[0][R]最小距离

                    City=i;//距离最近的城市号

                }

        }

        //printf("最近城市: %d   距离: %f\n",City,D);



        //倒位

        int Sindex=(R+1)%N;//从随机起始城市的--右边城市开始进行倒位

        int Eindex;

        for(i=0;i<N;i++)//扫描染色体

            if((*G1).state[k][i]==City)

                Eindex=i;

        if(Sindex>Eindex) //保证起点下标<终点下标

        {

           int temp=Sindex;

           Sindex=Eindex;

           Eindex=temp;

        }

        //printf("起点下标: %d   终点下标: %d\n",Sindex,Eindex);

        for(i=Sindex,j=Eindex;i<j;i++,j--)

        {

            int temp=(*G1).state[k][i];

            (*G1).state[k][i]=(*G1).state[k][j];

            (*G1).state[k][j]=temp;

        }

        (*G1).state[k][N]=(*G1).state[k][0];

        



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

        {    

            for(j=0;j<N+1;j++)

                printf("%d ",(*G1).state[i][j]);

            printf("\n");

        }

}