【c++】使用遗传算法求解旅行商问题（TSP）

最新推荐文章于 2024-05-22 17:54:50 发布
最新推荐文章于 2024-05-22 17:54:50 发布
阅读量3.2k 收藏 45
点赞数 2
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43184248/article/details/103687306
版权

数据来源：TSP数据
找到Symmetric traveling salesman problem (TSP)，下载相关数据。
本文选取了att48数据集。

遗传算法

遗传算法的基本运算过程如下：

  1. 初始化：设置进化代数计数器t=0、设置最大进化代数T、交叉概率、变异概率、随机生成M个个体作为初始种群P
  2. 个体评价：计算种群P中各个个体的适应度
  3. 选择运算：将选择算子作用于群体。以个体适应度为基础，选择最优个体直接遗传到下一代或通过配对交叉产生新的个体再遗传到下一代
  4. 交叉运算：在交叉概率的控制下，对群体中的个体两两进行交叉
  5. 变异运算：在变异概率的控制下，对群体中的个体两两进行变异，即对某一个体的基因进行随机调整
  6. 经过选择、交叉、变异运算之后得到下一代群体P1。
    重复以上1-6，直到遗传代数为T，以进化过程中所得到的具有最大适应度个体作为最优解输出，终止计算。

选择运算：轮盘赌法

选择算子采用轮盘赌选择，以每个个体的适应度为基础，为每个个体计算累积概率。
在这里插入图片描述
在这里插入图片描述
qa 表示个体a的累积概率，如上图所示个体1、2、3、4的累积概率分别为0.14、0.53、0.69、1。
随机生成一个0到1的浮点数f，若 qa < f <= qb，则个体b被选中。

交叉运算

①部分映射交叉
在这里插入图片描述
②顺序交叉
在这里插入图片描述
③基于位置的交叉
在这里插入图片描述

变异运算

变异算子随机进行多次，每次在个体基因序列中选择两个位置的基因进行交换。

完整代码如下：

#include <iostream>
#include <fstream>
#include <cmath>
#include <string>
#include <stdlib.h>
#include "time.h"     //程序运行时间 
#include <unistd.h>    //哈希函数 
#define CITY_NUM 48   //城市个数
#define POPSIZE 300    //种群个体数 
#define MAXVALUE 0x7ffffffff   //路径最大值上限
#define N 100000       //需要根据实际求得的路径值修正
#define MAX_GEN 50000   //最大进化代数 
#define CROSS 0.5     //交叉算子
#define MUT 0.05      //变异算子
using namespace std;

unsigned seed=(unsigned)time(0);    //每次产生不同的随机序列 
double Hash[CITY_NUM+1];

typedef struct CityPosition{
    double x;
    double y;
}CityPosition;                         //城市位置 

CityPosition CityPos[38]={};

double CityDistance[CITY_NUM][CITY_NUM];   //城市距离

typedef struct{
    int colony[POPSIZE][CITY_NUM+1];   //城市种群,默认出发城市编号为0，则城市编号的最后一个城市还应该为0
    double fitness[POPSIZE];           // 每个个体的适应度，即1/Distance[POPSIZE]
    double Distance[POPSIZE];          //每个个体的总路径
    int BestRooting[CITY_NUM+1];       //最优城市路径序列
    double BestFitness;                //最优路径适应值
    double BestValue;                  //最优路径长度
    int BestNum;                       //最优路径城市数目 
}TSP,*PTSP;

//计算城市距离CityDistance[i][j]
double CalculatDist(CityPosition CityPos[]){
    for(int i=0;i<CITY_NUM;i++){
        for(int j=0;j<CITY_NUM;j++){       //最后一个城市还应该返回到出发节点
            if(i!=j) CityDistance[i][j]=sqrt(pow(CityPos[j].x-CityPos[i].x,2)+pow(CityPos[j].y-CityPos[i].y,2));
            else CityDistance[i][i]=0;
        }
    }
}

//数组复制
void copy(int a[],int b[]){
    for(int i=0;i<CITY_NUM+1;i++)
    {
        a[i]=b[i];
    }
}


//用来检查新生成的节点是否在当前群体中，0号节点是默认出发节点和终止节点
bool check(TSP &city,int pop,int num,int k){
    for(int i=0;i<=num;i++){
        if(k==city.colony[pop][i])
            return true;    //新生成节点存在于已经生成的路径中
    }
    return false;    //新生成节点没有存在于已经生成的路径中
}

//种群初始化，即为city.colony[i][j]赋值
void InitColony(TSP &city){
    int r;
    for(int i=0;i<POPSIZE;i++){
        city.colony[i][0]=0;
        city.colony[i][CITY_NUM]=0;
        city.BestValue=MAXVALUE;
        city.BestFitness=0;     //适应值越大越好
    }
    for(int i=0;i<POPSIZE;i++)
    {
        for(int j=1;j<CITY_NUM;j++)
        {
            r=rand()%(CITY_NUM-1)+1;      //产生1～CITY_NUM-1之间的随机数
            while(check(city,i,j,r))      //随机产生城市序号，即为city.colony[i][j]赋值
            {
                r=rand()%(CITY_NUM-1)+1;
            }

            city.colony[i][j]=r;
        }
    }
}

//计算适应度,同时选出最优的 
void CalFitness(TSP &city){
    int start,end;
    int Best=0;
    for(int i=0;i<POPSIZE;i++){        //求每个个体的总路径，适应度 
        city.Distance[i]=0;
        for(int j=1;j<=CITY_NUM;j++){
            start=city.colony[i][j-1];
			end=city.colony[i][j];
            city.Distance[i]=city.Distance[i]+CityDistance[start][end];   //city.Distance[i]每个个体的总路径
        }
        city.fitness[i]=N/city.Distance[i];
        if(city.fitness[i]>city.fitness[Best])  //选出最大的适应度，即选出所有个体中的最短路径
            Best=i;
    }
    copy(city.BestRooting,city.colony[Best]);    //将最优个体拷贝给city.BestRooting
    city.BestFitness=city.fitness[Best];
    city.BestValue=city.Distance[Best];
    city.BestNum=Best;
}

//适应度 
double GetFittness(int a[CITY_NUM+1]){
    int i,start,end;
    double Distance=0;
    for(i=0;i<CITY_NUM;i++){
        start=a[i];
		end=a[i+1];
        Distance+=CityDistance[start][end];
    }
    return N/Distance;
}

//选择算子：轮盘赌法
void Select(TSP &city){
    int TempColony[POPSIZE][CITY_NUM+1];
    int i,j,t;
    double s;
    double GaiLv[POPSIZE];
    double SelectP[POPSIZE+1];
    double avg;
    double sum=0;
    for(i=0;i<POPSIZE;i++)	sum+=city.fitness[i];
    for(i=0;i<POPSIZE;i++)  GaiLv[i]=city.fitness[i]/sum;
    SelectP[0]=0;
    for(i=0;i<POPSIZE;i++)  SelectP[i+1]=SelectP[i]+GaiLv[i]*RAND_MAX;
    memcpy(TempColony[0],city.colony[city.BestNum],sizeof(TempColony[0]));
    for(t=1;t<POPSIZE;t++){
        double ran = rand() % RAND_MAX + 1;
        s= (double) ran / 100.0;
        for(i=1;i<POPSIZE;i++)	if(SelectP[i]>=s)	break;
        memcpy(TempColony[t],city.colony[i-1],sizeof(TempColony[t]));
    }
    for(i=0;i<POPSIZE;i++)	memcpy(city.colony[i],TempColony[i],sizeof(TempColony[i]));
}
 
//交叉：头尾不变，中间打乱顺序交叉
void Cross(TSP &city,double pc)//交叉概率是pc
{
    int i,j,t,l;
    int a,b,ca,cb;
    int Temp1[CITY_NUM+1],Temp2[CITY_NUM+1];
    for(i=0;i<POPSIZE;i++){
        double s=((double)(rand()%RAND_MAX))/RAND_MAX;
        if(s<pc){
            cb=rand()%POPSIZE;
            ca=cb;
            if(ca==city.BestNum||cb==city.BestNum)   //如果遇到最优则直接进行下次循环
                continue;

            l=rand()%(CITY_NUM/2)+1;      //1-一半的位置 
            a=rand()%(CITY_NUM-l)+1;     //全部 

            memset(Hash,0,sizeof(Hash));   //将s中当前位置后面的n个字节 用ch替换并返回s 。
            Temp1[0]=Temp1[CITY_NUM]=0;
            for(j=1;j<=l;j++)          //打乱顺序即随机，选出来的通过Hash标记为1
            {
                Temp1[j]=city.colony[cb][a+j-1]; //a+l=2~48 25~38
                Hash[Temp1[j]]=1;
            }
            for(t=1;t<CITY_NUM;t++)
            {
                if(Hash[city.colony[ca][t]]==0)
                {
                    Temp1[j++]=city.colony[ca][t];
                    Hash[city.colony[ca][t]]=1;
                }
            }
            memcpy(city.colony[ca],Temp1,sizeof(Temp1));
        }
    }

}

//对换变异
void Mutation(TSP &city,double pm)//变异概率是pm
{
    int i,m;
    int Temp[CITY_NUM+1];
    for(int k=0;k<POPSIZE;k++){
        double s=((double)(rand()%RAND_MAX))/RAND_MAX;    //随机产生概率0~1间
        i=rand()%POPSIZE;                       //随机产生0~POPSIZE之间的数
        if(s<pm&&i!=city.BestNum)               //i!=city.BestNum，即保证最优的个体不变异
        {
            int a,b,t;
            a=(rand()%(CITY_NUM-1))+1;
            b=(rand()%(CITY_NUM-1))+1;
            copy(Temp,city.colony[i]);
            if(a>b)    //保证让b>=a
            {
                t=a;
                a=b;
                b=t;
            }
            for(m=a;m<(a+b)/2;m++)
            {
                t=Temp[m];
                Temp[m]=Temp[a+b-m];
                Temp[a+b-m]=t;
            }

            if(GetFittness(Temp)<GetFittness(city.colony[i]))
            {
                a=(rand()%(CITY_NUM-1))+1;
                b=(rand()%(CITY_NUM-1))+1;
                memcpy(Temp,city.colony[i],sizeof(Temp));
                if(a>b)
                {
                    t=a;
                    a=b;
                    b=t;
                }
                for(m=a;m<(a+b)/2;m++)
                {
                    t=Temp[m];
                    Temp[m]=Temp[a+b-m];
                    Temp[a+b-m]=t;
                }

                    if(GetFittness(Temp)<GetFittness(city.colony[i]))
                    {
                        a=(rand()%(CITY_NUM-1))+1;
                        b=(rand()%(CITY_NUM-1))+1;
                        memcpy(Temp,city.colony[i],sizeof(Temp));
                        if(a>b)
                        {
                            t=a;
                            a=b;
                            b=t;
                        }
                        for(m=a;m<(a+b)/2;m++)
                        {
                            t=Temp[m];
                            Temp[m]=Temp[a+b-m];
                            Temp[a+b-m]=t;
                        }
                    }

            }
            memcpy(city.colony[i],Temp,sizeof(Temp));
        }
    }
}

void OutPut(TSP &city)
{
    cout<<"最佳路径为:"<<endl;
    for(int i=0;i<=CITY_NUM;i++){
    	cout<<city.BestRooting[i]+1;
		if(i!=CITY_NUM) cout<<"→";
	}
    cout<<endl<<"最佳路径长度为："<<city.BestValue<<endl;
}


int main(){
    TSP city;
    srand(seed);
    
	//读取数据 
	int m=0,n=0;
	double d=0;
	double num[CITY_NUM]={0},lont[CITY_NUM]={0},lati[CITY_NUM]={0};
	ifstream fin;
	fin.open("att48.txt");  
	while (fin>>d){
		if(m%3==0) num[n]=d;
		else if(m%3==1) lont[n]=d;
		else lati[n++]=d;
		m++;
	}
	
	CityPosition CityPos[CITY_NUM];
	for(int i=0;i<CITY_NUM;i++){
		CityPos[i].x=lont[i];
		CityPos[i].y=lati[i];
	}
	
	
    CalculatDist(CityPos);   //计算城市距离
    InitColony(city);       //生成初始种群
    CalFitness(city);       //计算适应度,同时选出最优的

    for(int i=0;i<MAX_GEN;i++){
		Select(city);           //选择：轮盘赌法
        Cross(city,CROSS);      //交叉
        Mutation(city,MUT);     //变异
        CalFitness(city);       //计算新的适应值
    }

    OutPut(city);    //输出
    return 0;
}

运行结果如下：
在这里插入图片描述
与网站提供的最优解比较，发现最佳路径是正确的，但最佳路径长度的结果有问题，还没有发现是哪里出了错误。

参考：
利用遗传算法求解TSP问题

遗传算法解决TSP问题（C++）

SC果
关注
  • 2
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++算法之使用遗传算法解决旅商问题
程序猿老樊的博客
07-29 1617
1、旅商问题          旅行商问题，即TSP问题（Traveling Salesman Problem）是数学领域中著名问题之一。           假设有一个旅行商人要拜访N个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。           路径的选择目标是要求得的路径路程为所有路径之中的最小值。 2、实现思路          ...
遗传算法解决TSP问题 旅行商问题 程序代码
05-29
遗传算法（Genetic Algorithm）即是通过模拟自然进化过程，搜索出最优解的方法，如可用来解决组合优化问题。 TSP问题即旅行商问题，假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。 程序用Microsoft Visual C++ 2010编写运行成功，更改各个城市坐标数据文件，即可输出最优路径。
人工智能应用-实验2-遗传算法求解 TSP 问题实验
最新发布
半岛铁盒里
05-22 1345
遗传算法求解TSP问题
遗传算法解决旅行商问题
04-17
旅行商问题是一类典型的NP完全问题，目前存在多种算法可以求取TSP问题的近似解，如贪心算法、最小生成树法等。遗传算法是解决NP问题的一种较理想的方法。内有完整可运行调试完毕代码，附有详细文档报告。
遗传算法解决TSP问题（C++版）
03-29
遗传算法解决TSP问题（C++版），内容详细，可以很好地帮助初学者学习遗传算法
遗传算法解决TSP问题---C++版
weixin_43965705的博客
11-21 1602
1、问题描述 旅行商问题 旅行商问题（Traveling Salesman Problem, TSP），又译为旅行推销员问题、货担郎问题，简称为TSP问题，是最基本的路线问题。假设有n个可直达的城市，一销售商从其中的某一城市出发，不重复地走完其余n-1个城市并回到原出发点，在所有可能的路径中求出路径长度最短的一条. 下面给出10个城市的位置信息： 2、求解流程图 3、程序清单 const int city_num = 10;//城市的数量，即基因的个数 const int idv_num = 1
遗传算法解决TSP问题
03-01
遗传算法是一种基于生物进化原理的优化方法，常用于解决复杂问题，如旅行商问题（Traveling Salesman Problem，简称TSP）。TSP是图论中的一个经典问题，它询问的是：给定一个城市列表和每对城市之间的距离，如何找到...
基于C++使用模拟退火算法求解旅行商问题.zip
05-11
以下是使用C++实现模拟退火算法求解旅行商问题的关键步骤： 1. **初始化**：首先，随机生成一个可行的旅行路线（即一个城市的排列顺序），作为初始解。可行性是指该路线满足每个城市只访问一次并返回起点的要求。 ...
c++遗传算法求解TSP问题_tsp_遗传算法_
09-29
总结起来，使用C++实现遗传算法求解TSP问题，涉及到编码、初始化、适应度函数、选择、交叉、变异和终止条件等多个环节。这种解决问题的方法展示了遗传算法在处理复杂优化问题时的有效性和灵活性。
用遗传算法求解旅行商问题及其代码设计.pdf-综合文档
05-23
根据提供的文件信息，我们知道该文档的主题是关于如何使用遗传算法来求解旅行商问题（TSP），并且文档中还包含了与之相关的代码设计。旅行商问题是一类经典的组合优化问题，其目标是寻找一条最短的路径，使旅行商从...
C++实现蚁群算法求解旅行商TSP问题源代码，含GUI界面.zip
09-16
C++实现蚁群算法求解旅行商TSP问题源代码，含GUI界面.zip 代码完整下载可用，可作为期末大作业和课程设计 C++实现蚁群算法求解旅行商TSP问题源代码，含GUI界面.zip 代码完整下载可用，可作为期末大作业和课程设计...
tsp:通过遗传算法在 C++ 和 CUDA 中使用可视化解决旅行商问题
07-02
茶匙 介绍 这是使用遗传算法 (GA) 解决旅行商问题 (TSP) 的 C++ 和 CUDA 实现。 可以在找到实现的详细信息。 此代码是在 Visual Studio 2010 中开发的； 但是，假设使用了适当的库和编译器，它应该可以在其他环境中工作并且是跨平台的。 先决条件 C++ 先决条件 C++ 编译器（Visual Studio 2010） CUDA 先决条件 64 位 5.0 版本（较新的版本应该可以使用 - 强烈建议使用 64 位，但不一定需要） 支持 NVIDIA 的 GPU（此代码专为 GTX-480 设计） 视频渲染先决条件 用法 主要代码位于“TSP_GA”中。 为方便起见，提供了完整的 Visual Studio 2010 解决方案。 您可以简单地打开该解决方案并继续，假设 CUDA 工具包已正确安装和配置。 一些路径已被硬编码。 您需要将“main.cp
利用遗传算法解决TSP问题（c++）
04-12
利用遗传算法解决TSP问题（c++）其中包括了50个城市。算法明了，简单易懂。
遗传算法解决tsp问题，使用c++编写（纯手写）
07-22
遗传算法解决tsp问题，使用c++编写（纯手写）
遗传算法解决TSP问题代码 C++
01-09
const int city_num = 144; //城市数目 const int individual_num = 2000; //种群初始值 const int age = 500; //遗传代数 const double varation_p = 0.1; //变异因子 typedef struct City_xy //储存给定的城市数据包含序号和坐标 { int order; double x; double y; }City_xy; typedef struct City { int mark; }City; typedef struct Population { City city[145]; //城市数组 double distance; //个体城市序列距离之和 double Fitness; //适应度 double Fitness_pi; }Population;
遗传算法解决旅行商(TSP)问题代码
10-16
本代码基于matlab实现了遗传算法解决TSP问题，并且对不同城市的个数进行了对比
遗传算法求解TSP旅行商问题C++（2020.11.11）
I have a dream, here my dreams come true!
11-11 2416
遗传算法求解TSP（C++）1、输入数据文件：bayg29.tsp2 、头文件3、所需的类4 、自定义函数5 、全局变量6 、主函数7 、运行结果 1、输入数据文件：bayg29.tsp 29个城市的编号和坐标数据如下所示； 1 1150.0 1760.0 2 630.0 1660.0 3 40.0 2090.0 4 750.0 1100.0 5 750.0 2030.0 6 1030.0 2070.0 7
遗传算法解决TSP问题（C++实现）
weixin_44735393的博客
01-17 3167
一、实验原理 巡回旅行商问题 1.1给定一组n个城市和俩俩之间的直达距离，寻找一条闭合的旅程，使得每个城市刚好经过一次且总的旅行距离最短。 1.2 TSP问题也称为货郎担问题，是一个古老的问题。最早可以追溯到1759年Euler提出的骑士旅行的问题。1948年，由美国兰德公司推动，TSP成为近代组合优化领域的典型难题。 1.3 TSP是一个具有广泛的应用背景和重要理论价值的组合优化问题。 近年来...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值