遗传算法(GA)求解中国旅行商问题

void QSort(float *R, int **P, int start, int end)
{
    if (start >= end) return;
    float tmp;
    int *ptr;
    if (start + 1 == end)//只有两个元素的时候直接排序
    {
        if (R[start] > R[end])
        {
            tmp = R[start];
            R[start] = R[end];
            R[end] = tmp;

            ptr = P[start];
            P[start] = P[end];
            P[end] = ptr;
        }
    }
    else
    {
        int i, j;
        i = start + 1; j = end;
        while (i < j)
        {
            while (R[i] <= R[start]&&i<end) i++;
            while (R[j] > R[start]&&j>start) j--;
            if (i < j)
            {
                tmp = R[i];
                R[i] = R[j];
                R[j] = tmp;

                ptr = P[i];
                P[i] = P[j];
                P[j] = ptr;
            }
        }
        tmp = R[start];
        R[start] = R[j];
        R[j] = tmp;

        ptr = P[start];
        P[start] = P[j];
        P[j] = ptr;

        QSort(R,P, start, j - 1);
        QSort(R, P,j + 1, end);
    }
}

void QSort(float *R, int **P, int start, int end);

/**
*遗传算法求解中国旅行商问题
*遗传算法使用的三个算子：
*（1）选择算子：根据适应度函数，选择适应度该高的个体进行下一步的杂交，
      反应进化过程中优胜劣汰的自然规律
*（2）交叉算子：交叉过程随机选择两个个体进行排队，根据预先设定的交叉概
      率Pc（0.5~0.8），决定是否交叉，交叉方法有单点交叉，两点交叉，和均
      匀交叉，这个类似于生物学中染色体交换基因片段
*（3）变异算子：变异算子将新个体的基因链中的某一位或者某一片段按变异概率
      Pm(0.001~0.1)进行变异
**/

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include"qsort.h"
#define INF 9999999  //指定为正无穷

//定义坐标点结构体
struct Point
{
    int x;
    int y;
};
/**********************************************
*以下过程包括：
*1. 读入31个城市的坐标位置
*2. 求任意两个城市间的距离
*3. 求一条完整路径的总长度
************************************************/
//从文件读取坐标点
Point* getPoints(int len, char* filename)
{
    Point* ps = (Point*)malloc(sizeof(Point)*len);
    FILE *infile;
    fopen_s(&infile, filename, "r");
    if (infile == NULL)
    {
        printf("文件打开失败\n");
    }
    for (int i = 0; i < len; i++)
    {
        fscanf_s(infile, "%d%d", &ps[i].x, &ps[i].y);
    }
    fclose(infile);
    return ps;
}

//求两点间的距离
float getDistance(Point p1, Point p2)
{
    return powf(powf(p1.x - p2.x, 2) + powf(p1.y - p2.y, 2), 0.5);
}

//计算任意两座城市间的距离，并保存在二维数组里
float** getAnyDistance(Point* ps, int len)//求任意两座城市之间的距离
{
    float** cost = (float**)malloc(sizeof(float*)*len);
    for (int i = 0; i < len; i++)
    {
        cost[i] = (float*)malloc(sizeof(float)*len);
    }
    for (int i = 0; i < len; i++)
    {
        for (int j = i + 1; j < len; j++)
        {
            cost[i][j] = getDistance(ps[i], ps[j]);
            cost[j][i] = cost[i][j];
        }
        cost[i][i] = 0;
    }
    return cost;
}

//计算一条环路的总长度，本算法里面的适应度就是以环路的长度为标准，越小适应度越高
float getTotalDistance(int *path, float **cost, int len)
{
    float total = 0;
    for (int i = 0; i < len - 1; i++)
    {
        total += cost[path[i]][path[i + 1]];
    }
    total += cost[path[len - 1]][path[0]];
    return total;
}

void copyPath(int *path1, int *path2, int len)
{
    while (len>0)
    {
        path1[len - 1] = path2[len - 1];
        len--;
    }
}
/****************************************************/
//判断值在不在数组的start位到end位之间，在返回标号，不在-1;
int isInArray(int value, int *s, int start, int end)
{   
    //printf("vslue=%d start=%d,end=%d\n", value,start,end);
    for (int i = start; i <= end; i++)
    {   
        //printf("s[%d] = %d\n", i,s[i]);
        if (s[i] == value)
        {   
            //printf("%d返回值：%d\n", i, s[i]);
            return i;
        }
    }    
        return -1;        
}

//两个个体交叉，产生两个新的个体的过程
void Cross(int *f1, int *f2, int *s1, int *s2, int start, int end, int len)
{   
    
    if (start >= end || end >= len)
    {
        return;
    }
    int j,k;
    for (int i = start; i <= end; i++)//交换start到end间的基因片段
    {
        s1[i] = f2[i];
        s2[i] = f1[i];
    }
    /**
    *理论上讲交叉过程应该保持其他部分不变化，但受制于本讨论问题中每一个城市
    *是唯一的，并且要求出现并且只能出现在回路中一次，（出发节点两次）,因此交换
    *基因片段后必将影响其他部分，这里的工作就是在尽量保证不变的前提下，解决冲突
    *本算法参考博客名为 xiaoning6p14 关于巡回旅行商问题的遗传算法路径交叉的思路
    *进行编写，使用部分匹配交叉（PMX）,详细算法地址为：
    *http://blog.sina.com.cn/s/blog_5d7883db0100bl04.html
    **/
    for (int i = (end+1)%len; i != start; i++,i%=len)
    {   
        j = isInArray(f1[i], s1, start, end);
        if (j!=-1)
        {  
            k = isInArray(f1[j], s1, start, end);
            while (k != -1)
            {
                j = k;
                k = isInArray(f1[j], s1, start, end);
            }
            s1[i] = f1[j];
        }
        else
        {
            s1[i] = f1[i];
        }

        j = isInArray(f2[i], s2, start, end);
        if (j != -1)
        {   
            k = isInArray(f2[j], s2, start, end);
            while (k != -1)
            {
                j = k;
                k = isInArray(f2[j], s2, start, end);
            }
            s2[i] = f2[j];
        }
        else
        {
            s2[i] = f2[i];
        }
    }
}

//随机产生一条环路
void getOneRandSolution(int *fR,int len)
{
    //srand(time(NULL));
    int x, y,tmp;
    for (int i = 0; i < len; i++)
    {
        fR[i] = i;
    }
    for (int i = 0; i < len / 2; i++)
    {
        x = rand() % len;
        y = rand() % len;
        tmp = fR[x];
        fR[x] = fR[y];
        fR[y] = tmp;
    }
}

//产生一个初始种族，Num表示种群数量,len表示维度（城市个数）
//每一个可行路径相当于一个个体
void initPopulation(int **P, int Num,int len)
{
    for (int i = 0; i < Num; i++)
    {
        getOneRandSolution(P[i], len);
    }
}


//选择过程，选择过程按照环路的总长度进行排序，选择前面的一般个体进行繁衍
//其他个体将会被淘汰，这里使用快速排序算法进行个体排列
void Select(int **P, int Num, int len, float *dis, float **cost)
{
    for (int i = 0; i < Num; i++)
    {
        dis[i] = getTotalDistance(P[i], cost, len);
    }
    //采用快速排序方法选择将种群个体按照优胜劣汰方式排列
    QSort(dis, P, 0, Num - 1);    
}

//交叉过程，产生下一代群体，start之前为已经选择的先进个体，
//start后面开始存放交叉个体，及覆盖掉原先的被淘汰个体
void Crossover(int **P, int start, int Num, int len, float Pc)
{  
    int index = start;
    //srand(time(NULL));
    int x, y,begin,end;
    float r;
    while (index < Num)
    {
        x = rand() % start;
        y = rand() % start;
        r = (float)(rand() % 1000) / 1000;
        if (Pc>r)
        {   
            begin = rand() % len;
            end = rand() % len;
            if (begin > end)
            {
                int t = begin;
                begin = end;
                end = t;
            }
            Cross(P[x], P[y], P[index], P[index + 1], begin, end, len);
            index += 2;
        }
    }
}

//基因的变异过程
void Mutation(int **P, int Num, int len,float Pm)
{
    //srand(time(NULL));
    float r;
    int x, y, tmp;
    for (int i = 0; i < Num; i++)
    {   
        r = (float)(rand() % 1000) / 1000;
        if (Pm>r)
        {
            x = rand() % len;
            y = rand() % len;
            tmp = P[i][x];
            P[i][x] = P[i][y];
            P[i][y] = tmp;
        }
    }
    
}

int *GA_TSP(char *fileName,int Num,int len,int round,int Iterators,float Pc,float Pm)
{   
    /***************初始化各种数据*******************/
    Point *ps = getPoints(len, fileName);
    float **cost = getAnyDistance(ps, len);
    int Nc = 0;//迭代次数
    int **P = (int**)malloc(sizeof(int*)*Num);
    int *result = (int*)malloc(sizeof(int)*len);
    float minDis = INF;
    float *dis = (float*)malloc(sizeof(float)*Num);
    for (int i = 0; i < Num; i++)
    {
        P[i] = (int*)malloc(sizeof(int)*len);
    }
    /*********************************************/
    while (round>0)//每一轮相当于旧的种族灭绝，再产生新的种群，这样做是为了尽可能避免局部极值
    {   
        Nc = 0;
        initPopulation(P, Num, len);
        while (Nc < Iterators)//繁衍的代数
        {
            Select(P, Num, len, dis, cost);//选择
            Crossover(P, Num / 2, Num, len, Pc);//交叉
            Mutation(P, Num, len, Pm);//变异
            Nc++;
        }
        Select(P, Num, len, dis, cost);
        if (dis[0] < minDis)//保存最优解
        {
            copyPath(result, P[0], len);
            minDis = dis[0];
        }
        round--;
    }
    /*******内存释放********/
    for (int i = 0; i < Num; i++)
    {
        free(P[i]);
    }
    free(P);
    free(dis);
    free(ps);
    for (int i = 0; i < len; i++)
    {
        free(cost[i]);
    }
    free(cost);
    return result;
}


int main()
{   
    srand(time(NULL));
    /**
    *种群规模400，城市个数31，轮数10，每个种群繁衍500代，交叉概率0.8，变异概率0.05
    **/
    int *solution = GA_TSP("points.txt", 200, 31, 100,500, 0.8, 0.05);
    Point *ps = getPoints(31, "points.txt");
    float **cost = getAnyDistance(ps, 31);
    printf("最短路径长度是<%fkm>，路径如下：\n", getTotalDistance(solution, cost, 31));
    for (int i = 0; i < 31; i++)
    {
        printf("%d ", solution[i]);
    }
    printf("\n");

    FILE *outfile;
    fopen_s(&outfile, "result.txt", "w");
    if (outfile == NULL)
    {
        printf("文件无法打开!\n");
    }
    else
    {
        for (int i = 0; i < 31; i++)
        {
            fprintf(outfile, "%d %d\n", ps[solution[i]].x, ps[solution[i]].y);
        }
        fclose(outfile);
    }

    free(solution);
    free(ps);
    for (int i = 0; i < 31; i++)
    {
        free(cost[i]);
    }
    free(cost);
    return 0;
}

 

城市坐标数据：

1304 2312
3639 1315
4177 2244
3712 1399
3488 1535
3326 1556
3238 1229
4196 1004
4312 790
4386 570
3007 1970
2562 1756
2788 1491
2381 1676
1332 695
3715 1678
3918 2179
4061 2370
3780 2212
3676 2578
4029 2838
4263 2931
3429 1908
3507 2367
3394 2643
3439 3201
2935 3240
3140 3550
2545 2357
2778 2826
2370 2975