遗传算法解决TSP问答(C)

合集下载

实验六:遗传算法求解TSP问题实验2篇

实验六:遗传算法求解TSP问题实验2篇

实验六:遗传算法求解TSP问题实验2篇第一篇:遗传算法的原理与实现1. 引言旅行商问题(TSP问题)是一个典型的组合优化问题,它要求在给定一组城市和每对城市之间的距离后,找到一条路径,使得旅行商能够在所有城市中恰好访问一次并回到起点,并且总旅行距离最短。

遗传算法作为一种生物启发式算法,在解决TSP问题中具有一定的优势。

本实验将运用遗传算法求解TSP问题,以此来探讨和研究遗传算法在优化问题上的应用。

2. 遗传算法的基本原理遗传算法是模拟自然界生物进化过程的一种优化算法。

其基本原理可以概括为:选择、交叉和变异。

(1)选择:根据问题的目标函数,以适应度函数来评估个体的优劣程度,并按照适应度值进行选择,优秀的个体被保留下来用于下一代。

(2)交叉:从选出的个体中随机选择两个个体,进行基因的交换,以产生新的个体。

交叉算子的选择及实现方式会对算法效果产生很大的影响。

(3)变异:对新生成的个体进行基因的变异操作,以保证算法的搜索能够足够广泛、全面。

通过选择、交叉和变异操作,不断迭代生成新一代的个体,遗传算法能够逐步优化解,并最终找到问题的全局最优解。

3. 实验设计与实施(1)问题定义:给定一组城市和每对城市之间的距离数据,要求找到一条路径,访问所有城市一次并回到起点,使得旅行距离最短。

(2)数据集准备:选择适当规模的城市数据集,包括城市坐标和每对城市之间的距离,用于验证遗传算法的性能。

(3)遗传算法的实现:根据遗传算法的基本原理,设计相应的选择、交叉和变异操作,确定适应度函数的定义,以及选择和优化参数的设置。

(4)实验流程:a. 初始化种群:随机生成初始种群,每个个体表示一种解(路径)。

b. 计算适应度:根据适应度函数,计算每个个体的适应度值。

c. 选择操作:根据适应度值选择一定数量的个体,作为下一代的父代。

d. 交叉操作:对父代进行交叉操作,生成新的个体。

e. 变异操作:对新生成的个体进行变异操作,以增加搜索的多样性。

利用遗传算法求解TSP问题

利用遗传算法求解TSP问题

利⽤遗传算法求解TSP问题⼀、摘要TSP问题是指给定平⾯上N个点及每点的坐标,求⼀条路径,遍历所有的点并回到起点,使这条路径长度最⼩。

TSP问题是⼀个组合优化问题。

该问题可以被证明具有NPC计算复杂性。

因此,任何能使该问题的求解得以简化的⽅法,都将受到⾼度的评价和关注。

遗传算法是⼈⼯智能⽅法的⼀种,⽤于求解各种传统⽅法不⽅便求解或耗时很长的问题。

下⾯给出遗传算法求解TSP问题的步骤。

在传统遗传算法求解TSP的基础上,提出了⼀种新的编码⽅式,并且讨论了⼀种优化⽅法的可⾏性。

本次实验的程序⾸先在matlab上验证了基本的算法,然⽽由于matlab运⾏较慢,故⼜移植到C++平台上,经过测试,实验结果良好。

⼆、算法实现遗传算法的实现主要包括编码、选择、交叉、编译、将个体放⼊新种群这么⼏个步骤,经过很多代的编译求解,以逼近最优解。

下⾯讨论每⼀个步骤的实现,其中编码⽅式是我在考虑了传统编码⽅式不利于计算的缺点下,重新设计的⼀种全新的编码⽅式。

编码在传统TSP问题中,编码可以直接采⽤⼆进制编码或⾃然编码的形式,⽐如直接把城市转化成(2,5,4,1,3,6)的形式,表⽰从2到5到4到1到3到6最后回到起点。

但是在求解TSP问题时,如果直接采⽤此种编码⽅式,会导致在交叉或变异时出现冲突的情况。

如(2,5,4,1,3,6)和(3,5,6,1,2,4)交换后变成了(2,5,6,1,2,6)和(3,5,4,1,3,4),显然路径出现了冲突的现象,传统的解决⽅式是通过逐步调整的⽅法来消除冲突,但是这种⽅法增加了编码的复杂度,不利于问题的求解,根据问题的特点,提出了采⽤⼀种插⼊序号的编码⽅式。

假设6个城市(1,2,3,4,5,6)现在有编码(1,1,2,2,1,3),让第n个编码表⽰n放在第⼏个空格处。

那么⽣成路径的规则是⾸先取1放在第⼀个(1),然后取2放在第⼀个空格处(2,1),然后取3放在第⼆个空格处(2,3,1),然后取4放在第⼆个空格处(2,4,3,1)然后取5放在第⼀个空格处(5,2,4,3,1)最后取6放在第3个空格处(5,2,6,4,3,1)。

利用遗传算法解决TSP问题课件

利用遗传算法解决TSP问题课件
编码方式
给每个城市一个固定的基因编号,例如10个城市为 0 1 2 3 4 5 6 7 8 9 ,随机地组成一个染色体(以下所有情况都以10个城市为例说明)。 约定这10个城市之间的行走路线为: 0123456789 (其余基因序列的路线同样道理)
两个城市间的距离(用r[i][j]表示)
轮盘选择
for(mem=0;mem<PopSize;mem++) sum+=population[mem].fitness; for(mem=0;mem<PopSize;mem++) //使小的选中的可能性大 x[mem]=sum-population[mem].fitness; sum=0.0; for(mem=0;mem<PopSize;mem++) sum+=x[mem]; /* Calculate relative fitness */ for(mem=0;mem<PopSize;mem++) population[mem].rfitness=x[mem]/sum;
仿真结果
仿真结果
一个完整路线的长度
例如基因序列为:0 8 2 9 7 5 6 4 1 3,存放在gene[0]~gene[9]中。 表示行旅行路线为: 0829756413 总路程为: r[gene[0]][gene[1]]+r[gene[1]][gene[2]]~ +r[gene[9]gene[0]]
交叉
例如一个基因序列为: 0 2 5 6 9 8 1 3 4 7 产生两个0~9的int型随机数,如得到2和6,将gene[2]和gene[6]之间的基因反序,得到: 0 2 1 8 9 6 5 3 4 7

遗传算法解决TSP问题【精品毕业设计】(完整版)

遗传算法解决TSP问题【精品毕业设计】(完整版)
2.2遗传算法原型:
GA(Fitness,Fitness_threshold,p,r,m)
Fitness:适应度评分函数,为给定假设赋予一个评估分数
Fitness_threshold:指定终止判据的阈值
p:群体中包含的假设数量
r:每一步中通过交叉取代群体成员的比例
m:变异率
初始化群体:P←随机产生的p个假设
在本程序的TSP问题中一共有20个城市,也就是在图模型中有20个顶点,因此一个染色体的长度为20。
3.3适应函数f(i)
对具有n个顶点的图,已知各顶点之间( , )的边长度d( , ),把 到 间的一条通路的路径长度定义为适应函数:
对该最优化问题,就是要寻找解 ,使f( )值最小。
3.4选择操作
选择作为交叉的双亲,是根据前代染色体的适应函数值所确定的,质量好的个体,即从起点到终点路径长度短的个体被选中的概率较大。
(2)交叉(Crossover):对于选中进行繁殖的两个染色体X,Y,以X,Y为双亲作交叉操作,从而产生两个后代X1,Y1.
(3)变异(Mutation):对于选中的群体中的个体(染色体),随机选取某一位进行取反运算,即将该染色体码翻转。
用遗传算法求解的过程是根据待解决问题的参数集进行编码,随机产生一个种群,计算适应函数和选择率,进行选择、交叉、变异操作。如果满足收敛条件,此种群为最好个体,否则,对产生的新一代群体重新进行选择、交叉、变异操作,循环往复直到满足条件。
3.变异:使用均匀的概率从Ps中选择m%的成员.对于选出的每个成员,在它表示中随机选择一个为取反
4.更新:P←Ps
5.评估:对于P中的每个h计算Fitness(h)
从P中返回适应度最高的假设
3.
3.1 TSP问题的图论描述

遗传算法的C语言实现(二)-----以求解TSP问题为例

遗传算法的C语言实现(二)-----以求解TSP问题为例

遗传算法的C语⾔实现(⼆)-----以求解TSP问题为例上⼀次我们使⽤遗传算法求解了⼀个较为复杂的多元⾮线性函数的极值问题,也基本了解了遗传算法的实现基本步骤。

这⼀次,我再以经典的TSP问题为例,更加深⼊地说明遗传算法中选择、交叉、变异等核⼼步骤的实现。

⽽且这⼀次解决的是离散型问题,上⼀次解决的是连续型问题,刚好形成对照。

⾸先介绍⼀下TSP问题。

TSP(traveling salesman problem,旅⾏商问题)是典型的NP完全问题,即其最坏情况下的时间复杂度随着问题规模的增⼤按指数⽅式增长,到⽬前为⽌还没有找到⼀个多项式时间的有效算法。

TSP问题可以描述为:已知n个城市之间的相互距离,某⼀旅⾏商从某⼀个城市出发,访问每个城市⼀次且仅⼀次,最后回到出发的城市,如何安排才能使其所⾛的路线最短。

换⾔之,就是寻找⼀条遍历n个城市的路径,或者说搜索⾃然⼦集X={1,2,...,n}(X的元素表⽰对n个城市的编号)的⼀个排列P(X)={V1,V2,....,Vn},使得Td=∑d(V i,V i+1)+d(V n,V1)取最⼩值,其中,d(V i,V i+1)表⽰城市V i到V i+1的距离。

TSP问题不仅仅是旅⾏商问题,其他许多NP完全问题也可以归结为TSP问题,如邮路问题,装配线上的螺母问题和产品的⽣产安排问题等等,也使得TSP问题的求解具有更加⼴泛的实际意义。

再来说针对TSP问题使⽤遗传算法的步骤。

(1)编码问题:由于这是⼀个离散型的问题,我们采⽤整数编码的⽅式,⽤1~n来表⽰n个城市,1~n的任意⼀个排列就构成了问题的⼀个解。

可以知道,对于n个城市的TSP问题,⼀共有n!种不同的路线。

(2)种群初始化:对于N个个体的种群,随机给出N个问题的解(相当于是染⾊体)作为初始种群。

这⾥具体采⽤的⽅法是:1,2,...,n作为第⼀个个体,然后2,3,..n分别与1交换位置得到n-1个解,从2开始,3,4,...,n分别与2交换位置得到n-2个解,依次类推。

遗传算法解决TSP问题,C++版(带注释)

遗传算法解决TSP问题,C++版(带注释)

//遗传算法解决简单TSP问题,(VC6.0)//一、定义头文件(defines.h)#ifndef DEFINES_H#define DEFINES_H///////////////////////////////// DEFINES /////////////////////////////////////// //窗口定义大小#define WINDOW_WIDTH 500#define WINDOW_HEIGHT 500//城市数量及城市在窗口显示的大小#define NUM_CITIES 20#define CITY_SIZE 5//变异概率,交叉概率及种群数量#define MUTATION_RATE 0.2#define CROSSOVER_RATE 0.75#define POP_SIZE 40//倍数#define NUM_BEST_TO_ADD 2//最小容许误差#define EPSILON 0.000001#endif//二、一些用得到的小函数(utils.h)// utils.h: interface for the Cutils class.//头文件名//////////////////////////////////////////////////////////////////////#ifndef UTILS_H#define UTILS_H#include <stdlib.h>#include <math.h>#include <sstream>#include <string>#include <iostream>using namespace std;//--------定义一些随机函数--------//----定义随机整数,随机[x,y]之间的整数---inline int RandInt(int x, int y){return rand()%(y-x+1)+x;}//--------------随机产生0到1之间的小数----------inline float RandFloat(){return rand()/(RAND_MAX + 1.0);}//-----------------随机产生0和1-------------inline bool RandBool(){if (RandInt(0,1))return true;elsereturn false;}//-----定义一些方便的小功能包括:整形转字符型,浮点型转字符型--- string itos(int arg);//converts an float to a std::stringstring ftos (float arg);//限制大小void Clamp(double &arg, double min, double max);void Clamp(int &arg, int min, int max);#endif//三、地图头文件(CmapTSP)#ifndef CMAPTSP_H#define CMAPTSP_H//如果没有定义那么就定义////////////////////////////////////////////////////类名:CmapTSP.h////描述:封装地图数据、城市坐标以及适应度计算。

(完整)用遗传算法求解TSP问题

(完整)用遗传算法求解TSP问题

用遗传算法求解TSP问题遗传算法(Genetic Algorithm——GA),是模拟达尔文的遗传选择和自然淘汰的生物进化过程的计算模型,它是由美国Michigan大学的J。

Holland教授于1975年首先提出的。

J.Holland 教授和它的研究小组围绕遗传算法进行研究的宗旨有两个:抽取和解释自然系统的自适应过程以及设计具有自然系统机理的人工系统。

遗传算法的大致过程是这样的:将每个可能的解看作是群体中的一个个体或染色体,并将每个个体编码成字符串的形式,根据预定的目标函数对每个个体进行评价,即给出一个适应度值。

开始时,总是随机的产生一些个体,根据这些个体的适应度,利用遗传算子-—选择(Selection)、交叉(Crossover)、变异(Mutation)对它们重新组合,得到一群新的个体.这一群新的个体由于继承了上一代的一些优良特性,明显优于上一代,以逐步向着更优解的方向进化.遗传算法主要的特点在于:简单、通用、鲁棒性强。

经过二十多年的发展,遗传算法已经在旅行商问题、生产调度、函数优化、机器学习等领域得到成功的应用。

遗传算法是一类可用于复杂系统优化的具有鲁棒性的搜索算法,与传统的优化算法相比,主要有以下特点:1、遗传算法以决策变量的编码作为运算对象.传统的优化算法往往直接决策变量的实际植本身,而遗传算法处理决策变量的某种编码形式,使得我们可以借鉴生物学中的染色体和基因的概念,可以模仿自然界生物的遗传和进化机理,也使得我们能够方便的应用遗传操作算子.2、遗传算法直接以适应度作为搜索信息,无需导数等其它辅助信息。

3、遗传算法使用多个点的搜索信息,具有隐含并行性。

4、遗传算法使用概率搜索技术,而非确定性规则。

遗传算法是基于生物学的,理解或编程都不太难。

下面是遗传算法的一般算法步骤:1、创建一个随机的初始状态初始种群是从解中随机选择出来的,将这些解比喻为染色体或基因,该种群被称为第一代,这和符号人工智能系统的情况不一样;在那里,问题的初始状态已经给定了。

遗传算法求解TSP问题

遗传算法求解TSP问题

遗传算法求解TSP问题实验六遗传算法求解TSP问题⼀、实验⽬的熟悉和掌握遗传算法的原理、流程和编码策略,并利⽤遗传求解函数优化问题,理解求解TSP问题的流程并测试主要参数对结果的影响。

⼆、实验内容1、参考实验系统给出的遗传算法核⼼代码,⽤遗传算法求解TSP的优化问题,分析遗传算法求解不同规模TSP问题的算法性能。

2、对于同⼀个TSP问题,分析种群规模、交叉概率和变异概率对算法结果的影响。

3、增加1种变异策略和1种个体选择概率分配策略,⽐较求解同⼀TSP问题时不同变异策略及不同个体选择分配策略对算法结果的影响。

4、上交源代码。

三、遗传算法求解TSP问题的流程图四、遗传算法求解不同规模的TSP问题的算法性能(1)遗传算法执⾏⽅式说明:适应度值计算⽅法:当前路线的路径长度●个体选择概率分配⽅法:适应度⽐例⽅法●选择个体⽅法:轮盘赌选择●交叉类型:PMX交叉●变异类型: 两点互换变异(2)实验模拟结果:图1-1(3)分析由图1-1可知,遗传算法执⾏时间随着TSP问题规模的增⼤⽽增⼤,并且⼤致为线性增长。

五、不同参数下的计算结果对⽐最⼤迭代步数:100交叉概率:0.85变异概率:0.15如表1-1或3-1-0-9-2-4-8-5-7-6,注意到这是⼀圈,顺时针或者逆时针都可以。

当种群规模为10,20时,并没有找到最优解。

(2)交叉概率对算法结果的影响实验次数:15种群规模:25最⼤迭代步数:100变异概率:0.15实验结果:在该情况下,交叉概率过低将使搜索陷⼊迟钝状态,得不到最优解。

种群规模:25最⼤迭代步数:100交叉概率:0.85实验结果:⼜表1-3可知,当变异概率过⼤或过低都将导致⽆法得到最优解。

注:(2)(3)的实验数据与(1)的实验数据不同,详见附录。

六、不同变异策略和个体选择概率分配策略对算法结果的影响(1)两点互换变异与插⼊变异的⽐较:●试验次数(CASNUM):10●城市数(POINTCNT):10●种群规模(POPSIZE):100●最⼤迭代步数(GENERATIONS):100●交叉概率(PC):0.85●变异概率(PM):0.15●选择个体⽅法:轮盘赌选择●交叉类型:PMX交叉●个体选择概率分配⽅法:适应度⽐例⽅法a.变异类型: 两点互换变异b.变异类型: 插⼊变异分析:两点互换变异20次模拟中,4次得到⾮最优解;⽽插⼊变异只有2次;插⼊变异的最好适应度平均值⽐两点互换变异⼩0.14755,最差适应度平均值和总的适应度平均值都⽐两点互换下,并且在Release下,运⾏时间前者⽐后者快218.3ms。

遗传算法解决TSP问题

遗传算法解决TSP问题
个),用两点交叉算子进行操作。 例如对于下面两个染色体个体
(1 3 4 | 5 2 9 | 8 6 7) (1 7 6 | 9 5 2 | 4 3 8)
通过两点交叉可得到子代染色体为 (1 3 4 | 9 5 2| 8 6 7) (1 7 6 | 5 2 9 | 4 3 8)
遗传算法解决TSP问题(二)
遗传算法解决TSP问题(二)
用交概率Pc,变异概率Pm.
(1)生成原始染色体种群
采用实数编码,以N个城市的序号作为一条可能的
路径。
例如对8个城市,可生成如下的染色体
代表一条路径,8,6,4,2,7,5,3,1.重复操作生成数目等
于n的染色体种群。
遗传算法解决TSP问题(二)
实际编程(采用48城市数据集,最优解10628)
1 .遗传变量
遗传算法解决TSP问题(三)
2.遗传方法
遗传算法解决TSP问题(三)
3 运行截图
遗传算法解决TSP问题(三)
遗传算法解决TSP问题(三)
谢谢观看
遗传算法解决TSP问题Algorithm)是模拟达尔文生物进化论的自然选择 和遗传学机理的生物进化过程的计算模型,是一种通过模拟自然进化过程搜 索最优解的方法。遗传算法是从代表问题可能潜在的解集的一个种群 (population)开始的,而一个种群则由经过基因(gene)编码的一定数 目的个体(individual)组成。每个个体实际上是染色体(chromosome)带有 特征的实体。染色体作为遗传物质的主要载体,即多个基因的集合,其内部 表现(即基因型)是某种基因组合,它决定了个体的形状的外部表现,如黑 头发的特征是由染色体中控制这一特征的某种基因组合决定的。因此,在一 开始需要实现从表现型到基因型的映射即编码工作。由于仿照基因编码的工 作很复杂,我们往往进行简化,如二进制编码,初代种群产生之后,按照适 者生存和优胜劣汰的原理,逐代(generation)演化产生出越来越好的近似 解,在每一代,根据问题域中个体的适应度(fitness)大小选择 (selection)个体,并借助于自然遗传学的遗传算子(genetic operators) 进行组合交叉(crossover)和变异(mutation),产生出代表新的解集的 种群。这个过程将导致种群像自然进化一样的后生代种群比前代更加适应于 环境,末代种群中的最优个体经过解码(decoding),可以作为问题近似 最优解。

遗传算法求解TSP问题报告

遗传算法求解TSP问题报告

遗传算法求解TSP问题实验报告一、实验要求:以旅行商问题(TSP)为例做模拟进化搜索技术实验,并提交实验研究报告。

二、实验思路:bool fnCreateRandomGene(); //产生随机基因bool fnGeneAberrance(); //基因变异bool fnGeneMix(); //基因交叉产生新的个体测试并淘汰适应度低的个体bool fnEvalAll(); //测试所有基因的适应度int fnEvalOne(T &Gene); //测试某一个基因的适应度void Crossover( int nFatherA, int nFatherB);void fnDispProbability(); //显示每个个体的权值Crossover()——两染色体的交叉实现输入参数:1、nFatherA 父染色体A2、nFatherB 父染色体B3、nMode 交叉方式返回值:空注:现有交叉方式1、常规交叉方式,该方式比《现代计算方法》(邢文训等编著)p178给出的“非常规码的常规交配法”稍复杂些。

书中只随机选择一个交配位,两个后代交配位之前的基因分别继承双亲的交配位之前的基因。

本程序中,是随机选择两个不相同的交配位,后代在这两个交配位之间继承双亲在这两个交配位之间的基因如父A 1 2 3 | 4 5 6 7 | 8 9 10父B 4 7 8 | 3 2 5 9 | 1 6 10子A 8 3 2 | 4 5 6 7 | 9 1 10子B 1 4 6 | 3 2 5 9 | 7 8 102、贪心交叉方式(Greedy Crossover),具体算法可参见谢胜利,等.求解TSP问题的一种改进的遗传算法[J].计算机工程与应用,2002(8):58~245.三、实验代码:#include <fstream>#include<iostream>#include <vector>#include <algorithm>#include<math.h>#include <time.h>#include <stdlib.h>#include "def.h"#include "TSP.h"void main(){ifstream input_file;ofstream output_file;time_t time1,time2;int _GENERATION_AMOUNT;int times;int _CITY_AMOUNT=-1;int ii,j,k;std::vector<double> x;std::vector<double> y;char readfile[50];const char* writefile="tsp.txt";double tempx[10000],tempy[10000];cout<<"打开城市坐标文件:";cin>>readfile;input_file.open(readfile);if(!input_file){cout<<"打开错误!";return;}cout<<"读入城市坐标........"<<endl;while(1){if(!input_file.eof()){_CITY_AMOUNT++;input_file>>tempx[_CITY_AMOUNT]>>tempy[_CITY_AMOUNT];if(tempx[_CITY_AMOUNT]<0||tempy[_CITY_AMOUNT]<0){cout<<"文件格式有误!";return;}}elsebreak;}if( _CITY_AMOUNT==-1){cout<<"文件格式有误!";return;}input_file.close();_CITY_AMOUNT=_CITY_AMOUNT+1;x.reserve(_CITY_AMOUNT);y.reserve(_CITY_AMOUNT);lpCityDistance.reserve(_CITY_AMOUNT*_CITY_AMOUNT);for(k=0;k<_CITY_AMOUNT;k++){x[k]=tempx[k];y[k]=tempy[k];}cout<<"已存入的城市信息为:"<<endl;for(ii=0;ii<_CITY_AMOUNT;ii++)cout<<"第"<<ii+1<<"个城市"<<"("<<x[ii]<<","<<y[ii]<<")"<<endl;lpCityDistance.clear();for(k=0;k<_CITY_AMOUNT;k++){lpCityDistance[k*_CITY_AMOUNT+k]=0;for(j=k+1;j<_CITY_AMOUNT;j++){lpCityDistance[k*_CITY_AMOUNT+j]=lpCityDistance[j*_CITY_AMOUNT+k] =sqrt((x[k]-x[j])*(x[k]-x[j])+(y[k]-y[j])*(y[k]-y[j]));}}cout<<"输入进化代数:"<<endl;cin>>times;cout<<"输入种群大小:(大于城市个数小于10000)"<<endl;cin>> _GENERATION_AMOUNT;while(_GENERATION_AMOUNT>=10000||_GENERATION_AMOUNT<_CITY_AMOUNT){cout<<"种群数输入错误!请重新输入(大于城市个数小于10000)"<<endl;cin>> _GENERATION_AMOUNT;}Csga<_CONTAINER, _CONTAINER_P> CUnit(times,_GENERATION_AMOUNT,_CITY_AMOUNT); //初始化time1=time(NULL);//开始遗传算法if(!CUnit.fnCreateRandomGene()) //产生随机基因//产生随机的基因{exit(0);}//循环基因编译,杂交,淘汰过程CUnit.fnEvalAll(); //测试所有基因的适应度for ( int i = 0; i<times; ++i ){//CUnit.fnDispProbability();//显示每个个体的权值CUnit.fnGeneAberrance(); //基因变异//基因变异//CUnit.fnDispProbability();//显示每个个体的权值CUnit.fnGeneMix();//交叉产生新的个体测试并淘汰适应度低的个体//基因杂交CUnit.fnEvalAll(); //测试所有基因的适应度// 每隔_DISP_INTERV AL显示一次结果if ( (i+1)%_DISP_INTERV AL == 0 || i == 0){cout << "第" << i+1 << "代" <<endl;CUnit.fnDispProbability();CUnit.fnDispHistoryMin();}}CUnit.fnDispHistoryMin();time2=time(NULL);cout<<"\n\n计算用时为:"<<difftime(time2,time1)<<"s"<<endl;}四、实验结果:。

遗传算法解决TSP问题

遗传算法解决TSP问题

遗传算法解决TSP问题姓名:学号:专业:问题描叙TSP问题即路径最短路径问题,从任意起点出发(或者固定起点),依次经过所有城市,一个城市只能进入和出去一次,所有城市必须经过一次,经过终点再到起点,从中寻找距离最短的通路。

通过距离矩阵可以得到城市之间的相互距离,从距离矩阵中的到距离最短路径,解决TSP问题的算法很多,如模拟退火算法,禁忌搜索算法,遗传算法等等,每个算法都有自己的优缺点,遗传算法收敛性好,计算时间少,但是得到的是次优解,得不到最有解。

算法设计遗传算法属于进化算法的一种,它通过模仿自然界的选择与遗传的机理来寻找最优解.遗传算法有三个基本算子:选择、交叉和变异。

数值方法求解这一问题的主要手段是迭代运算。

一般的迭代方法容易陷入局部极小的陷阱而出现"死循环"现象,使迭代无法进行。

遗传算法很好地克服了这个缺点,是一种全局优化算法。

生物在漫长的进化过程中,从低等生物一直发展到高等生物,可以说是一个绝妙的优化过程。

这是自然环境选择的结果。

人们研究生物进化现象,总结出进化过程包括复制、杂交、变异、竞争和选择。

一些学者从生物遗传、进化的过程得到启发,提出了遗传算法。

算法中称遗传的生物体为个体,个体对环境的适应程度用适应值(fitness)表示。

适应值取决于个体的染色体,在算法中染色体常用一串数字表示,数字串中的一位对应一个基因。

一定数量的个体组成一个群体。

对所有个体进行选择、交叉和变异等操作,生成新的群体,称为新一代遗传算法计算程序的流程可以表示如下:第一步准备工作(1)选择合适的编码方案,将变量(特征)转换为染色体(数字串,串长为m)。

通常用二进制编码。

(2)选择合适的参数,包括群体大小(个体数M )、交叉概率PC和变异概率Pm。

(3)确定适应值函数f (x)。

f(x)应为正值。

第二步形成一个初始群体(含M个个体)。

在边坡滑裂面搜索问题中,取已分析的可能滑裂面组作为初始群体。

第三步对每一染色体(串)计算其适应值fi,同时计算群体的总适应值。

用遗传算法解决TSP问题

用遗传算法解决TSP问题

用遗传算法解决TSP问题设计思路:1.初始化城市距离采用以城市编号(i,j=1代表北京,=2代表上海,=3代表天津,=4代表重庆,=5代表乌鲁木齐)为矩阵行列标的方法,输入任意两个城市之间的距离,用矩阵city表示,矩阵中的元素city(i,j)代表第i个城市与第j个城市间的距离。

2.初始化种群通过randperm函数,生成一个一维随机向量(是整数1,2,3,4,5的任意排列),然后将其赋给二维数组group的第一列,作为一个个体。

如此循环N次(本例生成了50个个体),生成了第一代种群,种群的每个个体代表一条路径。

3.计算适应度采用的适应度函数为个体巡回路径的总长度的函数。

具体为adapt(1,i)=(5*maxdis-dis) (1) 在式(1)中,adapt(1,i)表示第i个个体的适应度函数,maxdis为城市间的最大距离,为4077km,dis为个体巡回路径的总长度,这样定义的适应度,当路经越短时适应度值越大。

在适应度值的基础上,给出的计算个体期望复制数的表达式为adaptnum(1,i)=(N* adapt(1,i)/ sumadapt) (2) 其中,sumadapt为种群适应度之和。

4.复制采用优秀个体的大比例保护基础上的随机数复制法。

具体做法为在生成下一代个体时,先将最大适应度对应的路径个体以较大的比例复制到下一代,然后再用随机数复制法生成下一代的其他个体。

其中,有一个问题必须考虑,即若某一次生成的随机数过大,结果能复制一个或极少个样本。

为了避免这一情况,采用了限制措施,即压低了随机数的上限。

5.交叉采用的方法为按步长的单点交叉,为随机选择一对样本,再随机选择一个交叉点位置,按一定的步长进行交叉点的选择。

选择一个步长而不是将其设为1,是因为若某一位置处的城市代码因为进行了交叉而发生了改变,则其经过该处的两个距离都会改变。

这种交叉兼有遗传和变异两方面的作用,因为若交叉点处的城市编号都相同,则对两个个体而言交叉后样本无变化,否则样本有变化。

遗传算法解决TSP问题(C++)

遗传算法解决TSP问题(C++)

遗传算法解决TSP问题(C++版)遗传算法流程:交叉,编译,计算适应度,保存最优个体。

其中交叉过程是选择最优的两个染色体进行交叉操作,本文采用的是轮盘赌算法。

#include<iostream>#include<cstdlib>#include<ctime>using namespace std;#define population 200//种群数量#define pc 0.9//交叉的概率#define pm 0.1//变异的概率#define count 200//迭代的次数#define num 10//城市的数量int** city;//存放每个个体的访问顺序int path[10][10] = {//0, 1, 2, 3, 4, 5, 6, 7, 8, 9{ 0, 23, 93, 18, 40, 34, 13, 75, 50, 35 },//0{ 23, 0, 75, 4, 72, 74, 36, 57, 36, 22 },//1{ 93, 75, 0, 64, 21, 73, 51, 25, 74, 89 },//2{ 18, 4, 64, 0, 55, 52, 8, 10, 67, 1 }, //3{ 40, 72, 21, 55, 0, 43, 64, 6, 99, 74 }, //4{ 34, 74, 73, 52, 43, 0, 43, 66, 52, 39 },//5{ 13, 36, 51, 8, 64, 43, 0, 16, 57, 94 },//6{ 75, 57, 25, 10, 6, 66, 16, 0, 23, 11 }, //7{ 50, 36, 74, 67, 99, 52, 57, 23, 0, 42 },//8{ 35, 22, 89, 1, 74, 39, 94, 11, 42, 0 }//9};int* dis;//存放每个个体的访问顺序下的路径长度double* fitness;//存放灭个个体的适应度int min_dis = 1000000;int min_index = -1;int* min_path;//初始化种群void init(){int *a = new int[num];for (int i = 0; i<num; i++){a[i] = i;}city = new int*[population];for (int i = 0; i<population; i++){city[i] = new int[num];}for (int i = 0; i<population; i++){for (int j = num - 1; j >= 0; j--){int n = rand() % (j + 1);//产出的数是0-j,保证交换的后面的数不会再被交换swap(a[j], a[n]);//保证a里面全是0-(num-1)的数,无重复的数,只是顺序颠倒city[i][j] = a[j];}}delete[]a;dis = new int[population];fitness = new double[population];min_path = new int[num];}//计算适应度void compute(){//cout << "do compute now. " << endl;double total = 0;for (int i = 0; i<population; i++){//计算每种情况下,路径的长度dis[i] = 0;int a = city[i][0], b;for (int j = 1; j<num; j++){b = city[i][j];dis[i] += path[a][b];a = b;}dis[i] += path[b][city[i][0]];fitness[i] = 1.0 / dis[i];//以距离的倒数作为适应度函数值total += fitness[i];}}//选择适应度高的物种,采用轮盘赌算法int select(){double total = 0;for (int i = 0; i<population; i++){total += fitness[i];}double size = rand() / (double)RAND_MAX * total;//保证不产生0//cout << "size " << size << endl;double sum = 0;int i = 0;while (sum <= size&&i<population){sum += fitness[++i];}return --i;//返回被选中的个体}int getMinDis(){int result = dis[0];int index = 0;for (int i = 1; i<population; i++){if (result > dis[i]){result = dis[i];index = i;}}return index;}int getMaxDis(){int result = dis[0];int index = 0;for (int i = 1; i<population; i++){if (result < dis[i]){result = dis[i];index = i;}}return index;}void save(){int current_min_index = getMinDis();int current_max_index = getMaxDis();if (dis[current_min_index] < min_dis){min_dis = dis[current_min_index];for (int i = 0; i < num; i++){min_path[i] =city[current_min_index][i];}//cout << "current min dis is: " << min_dis << endl;}else{for (int i = 0; i<num; i++){city[current_max_index][i] = min_path[i];}dis[current_max_index] = min_dis;fitness[current_max_index] = 1.0 / min_dis;}}//最优保存算法bool isExist(int value, int* array, int len){for (int i = 0; i<len; i++){if (value == array[i])return true;}return false;}void convert(int p1, int p2, int* src, int* dst){int len = p2 - p1 + 1;int* temp = new int[len];for (int i = p1; i <= p2; i++){temp[i - p1] = src[i];}int j = (p2 + 1) % num;for (int i = 1; i <= num; i++){int index = (i + p2) % num;if (!isExist(dst[index], temp, len)){dst[j] = dst[index];j = (j + 1) % num;}}for (int i = p1; i <= p2; i++){dst[i] = src[i];}delete[]temp;}//交叉,采用次序交叉算法void cross(){//cout << "do cross now. " << endl;for (int k = 0; k<population; k += 2){int a = select();int b = select();while (a == b){b = select();//保证被选中的个体不是一样的//cout << "same " << b << endl;}//cout << "choose popuilation" << a << " " << b << endl;double p = rand() / double(RAND_MAX);//cout << "cross rate is " << p << endl;int* a1 = new int[num];int* a2 = new int[num];int* b1 = new int[num];int* b2 = new int[num];for (int i = 0; i<num; i++){a1[i] = city[a][i];a2[i] = city[b][i];b1[i] = a2[i];b2[i] = a1[i];}if (p<pc)//满足交叉条件{//选择交叉的两点,并保证p1<p2int p1 = -1;int p2 = -1;while (p1 == p2){p1 = rand() % num;p2 = rand() % num;if (p1>p2){swap(p1, p2);}}//cout << "choose pos " << p1 << " " << p2 << endl;//开始交叉convert(p1, p2, a1, b1);convert(p1, p2, a2, b2);for (int i = 0; i<num; i++){city[k][i] = b1[i];city[k + 1][i] = b2[i];}}else{for (int i = 0; i<num; i++){city[k][i] = a1[i];city[k + 1][i] = a2[i];}}delete[]a1;delete[]a2;delete[]b1;delete[]b2;}}//变异,采用对换操作进行变异void morphis(){//cout << "do morphis now. " << endl;for (int i = 0; i<population; i++){double p = rand() / double(RAND_MAX);//cout << "morphis rate is " << p << endl;if (p<pm)//执行变异{int a = -1, b = -1;while (a == b){a = rand() % num;b = rand() % num;}swap(city[i][a], city[i][b]);}}}int getdis(){//compute();int result = dis[0];int index = 0;for (int i = 1; i<population; i++){if (result > dis[i]){result = dis[i];index = i;}}return result;}//释放申请的数组的空间void dispose(){for (int i = 0; i<population; i++){delete[]city[i];}delete[]city;delete[]dis;delete[]fitness;}int main(){init();//初始化种群int i = 0;srand(time(0));compute();while (i<count){cross();//交叉morphis();//变异compute();//计算适应度save();//保存当前最优的个体//cout << "count " << i++ << endl;cout << getdis() << " ";//输出结果//cout << min_index << " ";if (++i % 10 == 0)cout << endl;}compute();cout << "min distance is: " << min_dis << endl;for (int i = 0; i<num; i++)cout << min_path[i] << " ";cout << endl;dispose();//释放空间return 0;}。

最新[PPT]利用遗传算法解决TSP问题ppt课件

最新[PPT]利用遗传算法解决TSP问题ppt课件
[PPT]利用遗传算法解决TSP 问题
TSP问题,又称旅行商问题, 旅行推销员问题,是指对于给定 的n 个城市,旅行商从某一城市出发不重复的访问其余城市 后回到出发的城市,要求找出一条旅行路线,是总的旅行路程最短.
遗传算法(Genetic Algorithms,GA)是一种基 于自然群体遗传演化机制的算法, 它模拟自然界 生物进化过程, 采用人工进化的方式对目标空间 进行随机化搜索。它将问题域中的可能解看作是 群体的个体, 并将个体编码成符号串形式( 即染色 体) , 模拟生物进化过程, 对群体反复进行杂交等 操作, 根据预定的适应度函数对每个个体进行评 价, 依据优胜劣汰的进化规则, 不断得到更优的群 体, 同时搜索优化群体中的最优个体, 求得满足要 求的最优解。
产生两个0~9的int型随机数,如得到2和6, 将gene[2]和gene[6]之间的基因反序,得到:
0218965347
变异
例如一个基因序列为: 0256981347
产生两个0~9的int型随机数,如得到2和6, 将gene[2]和gene[6] 的基因交换,得到: 0216985347
仿真结果

for(mem=0;mem<PopSize;mem++)

Байду номын сангаас
sum+=x[mem];

/* Calculate relative fitness */

for(mem=0;mem<PopSize;mem++)

population[mem].rfitness=x[mem]/sum;
交叉
例如一个基因序列为: 0256981347
Q恤%捎z衍cP耸M触tZM咆7眨Vt嚼(kn苑JR空

遗传算法解决TSP问题

遗传算法解决TSP问题

遗传算法解决旅行商(TSP)问题旅行商问题(traveling saleman problem,简称tsp):已知N个城市之间的相互距离,现有一个推销员必须遍访这n个城市,并且每个城市只能访问一次,最后又必须返回出发城市。

如何安排他对这些城市的访问次序,可使其旅行路线的总长度最短?本程序使用MATLAB软件,利用遗传算法解决TSP问题。

程序使用如下:gatsp 为主程序,cityNum为城市个数,在此程序中可以设置为30、50和70。

Inn是种群个数,gnmax是最大迭代次数,pc是交叉概率,pm是变异概率。

算法程序运行结果如下:算法程序如下(不同的function需放在不同的.m文件中):注:红色部分不属于算法内容,仅作间隔标致。

-------------------------------------------------------------------------------------------------------%主程序:%遗传算法求解tspfunction gaTSPCityNum=30;[dislist,Clist]=tsp(CityNum);inn=100; %初始种群大小gnmax=1000; %最大代数pc=0.9; %交叉概率pm=0.08; %变异概率%产生初始种群for i=1:inns(i,:)=randperm(CityNum);end[f,p]=objf(s,dislist);gn=1;while gn<gnmax+1for j=1:2:innseln=sel(s,p); %选择操作scro=cro(s,seln,pc); %交叉操作scnew(j,:)=scro(1,:);scnew(j+1,:)=scro(2,:);smnew(j,:)=mut(scnew(j,:),pm); %变异操作smnew(j+1,:)=mut(scnew(j+1,:),pm);ends=smnew; %产生了新的种群[f,p]=objf(s,dislist); %计算新种群的适应度%记录当前代最好和平均的适应度[fmax,nmax]=max(f);ymean(gn)=1000/mean(f);ymax(gn)=1000/fmax;%记录当前代的最佳个体x=s(nmax,:);drawTSP(Clist,x,ymax(gn),gn,0);gn=gn+1;%pause;endgn=gn-1;figure(2);plot(ymax,'r'); hold on;plot(ymean,'b');grid;title('搜索过程');legend('最优解','平均解');string1=['最终度',num2str(ymax(gn))];gtext(string1);End----------------------------------------------------------------- %交叉程序:function scro=cro(s,seln,pc);bn=size(s,2);pcc=pro(pc); %根据交叉概率决定是否进行交叉操作,1则是,0则否scro(1,:)=s(seln(1),:);scro(2,:)=s(seln(2),:);if pcc==1c1=round(rand*(bn-2))+1; %在[1,bn-1]范围内随机产生一个交叉位c2=round(rand*(bn-2))+1;chb1=min(c1,c2);chb2=max(c1,c2);middle=scro(1,chb1+1:chb2);scro(1,chb1+1:chb2)=scro(2,chb1+1:chb2);scro(2,chb1+1:chb2)=middle;for i=1:chb1while find(scro(1,chb1+1:chb2)==scro(1,i))zhi=find(scro(1,chb1+1:chb2)==scro(1,i));y=scro(2,chb1+zhi);scro(1,i)=y;endwhile find(scro(2,chb1+1:chb2)==scro(2,i))zhi=find(scro(2,chb1+1:chb2)==scro(2,i));y=scro(1,chb1+zhi);scro(2,i)=y;endendfor i=chb2+1:bnwhile find(scro(1,1:chb2)==scro(1,i))zhi=find(scro(1,1:chb2)==scro(1,i));y=scro(2,zhi);scro(1,i)=y;endwhile find(scro(2,1:chb2)==scro(2,i))zhi=find(scro(2,1:chb2)==scro(2,i));y=scro(1,zhi);scro(2,i)=y;endendendEnd----------------------------------------------------------------- %变异程序:function snnew=mut(snew,pm);bn=size(snew,2);snnew=snew;pmm=pro(pm); %根据变异概率决定是否进行变异操作,1则是,0则否if pmm==1c1=round(rand*(bn-2))+1; %在[1,bn-1]范围内随机产生一个变异位c2=round(rand*(bn-2))+1;chb1=min(c1,c2);chb2=max(c1,c2);x=snew(chb1+1:chb2);snnew(chb1+1:chb2)=fliplr(x);endend----------------------------------------------------------------- %适应度计算:function [f,p]=objf(s,dislist);inn=size(s,1); %读取种群大小for i=1:innf(i)=caldist(dislist,s(i,:)); %计算函数值,即适应度endf=1000./f';%计算选择概率fsum=0;for i=1:innfsum=fsum+f(i)^15;endfor i=1:innps(i)=f(i)^15/fsum;end%计算累积概率p(1)=ps(1);for i=2:innp(i)=p(i-1)+ps(i);endp=p';end----------------------------------------------------------------- %选着个体程序:function seln=sel(s,p);inn=size(p,1);%从种群中选择两个个体for i=1:2r=rand; %产生一个随机数prand=p-r;j=1;while prand(j)<0j=j+1;endseln(i)=j; %选中个体的序号endend-----------------------------------------------------------------%城市坐标:function [DLn,cityn]=tsp(n)if n==10city10=[0.4 0.4439;0.2439 0.1463;0.1707 0.2293;0.2293 0.761;0.5171 0.9414;0.8732 0.6536;0.6878 0.5219;0.8488 0.3609;0.6683 0.2536;0.6195 0.2634];%10 cities d'=2.691for i=1:10for j=1:10DL10(i,j)=((city10(i,1)-city10(j,1))^2+(city10(i,2)-city10(j,2))^ 2)^0.5;endendDLn=DL10;cityn=city10;endif n==30city30=[41 94;37 84;54 67;25 62;7 64;2 99;68 58;71 44;54 62;83 69;64 60;18 54;22 60;83 46;91 38;25 38;24 42;58 69;71 71;74 78;87 76;18 40;13 40;82 7;62 32;58 35;45 21;41 26;44 35;4 50];%30 cities d'=423.741 by D B Fogelfor i=1:30for j=1:30DL30(i,j)=((city30(i,1)-city30(j,1))^2+(city30(i,2)-city30(j,2))^ 2)^0.5;endendDLn=DL30;cityn=city30;endif n==50city50=[31 32;32 39;40 30;37 69;27 68;37 52;38 46;31 62;30 48;21 47;25 55;16 57;17 63;42 41;17 33;25 32;5 64;8 52;12 42;7 38;5 25; 10 77;45 35;42 57;32 22;27 23;56 37;52 41;49 49;58 48;57 58;39 10;46 10;59 15;51 21;48 28;52 33;58 27;61 33;62 63;20 26;5 6;13 13;21 10;30 15;36 16;62 42;6369;52 64;43 67];%50 cities d'=427.855 by D B Fogelfor i=1:50for j=1:50DL50(i,j)=((city50(i,1)-city50(j,1))^2+(city50(i,2)-city50(j,2))^ 2)^0.5;endendDLn=DL50;cityn=city50;endif n==75city75=[48 21;52 26;55 50;50 50;41 46;51 42;55 45;38 33;33 34;45 35;40 37;50 30;55 34;54 38;26 13;15 5;21 48;29 39;33 44;15 19;16 19;12 17;50 40;22 53;21 36;20 30;26 29;40 20;36 26;62 48;67 41;62 35;65 27;62 24;55 20;35 51;30 50;45 42;21 45;36 6;6 25;11 28;26 59;30 60;22 22;27 24;30 20;35 16;54 10;50 15;44 13;35 60;40 60;40 66;31 76;47 66;50 70;57 72;55 65;2 38;7 43;9 56;15 56;10 70;17 64;55 57;62 57;70 64;64 4;59 5;50 4;60 15;66 14;66 8;43 26];%75 cities d'=549.18 by D B Fogelfor i=1:75for j=1:75DL75(i,j)=((city75(i,1)-city75(j,1))^2+(city75(i,2)-city75(j,2))^ 2)^0.5;endendDLn=DL75;cityn=city75;endend----------------------------------------------------------------- %根据交叉概率决定是否进行交叉操作:function pcc=pro(pc);test(1:100)=0;l=round(100*pc);test(1:l)=1;n=round(rand*99)+1;pcc=test(n);end----------------------------------------------------------------- %计算城市距离矩阵:function F=caldist(dislist,s)distan=0;n=size(s,2);for i=1:n-1distan=distan+dislist(s(i),s(i+1));enddistan=distan+dislist(s(n),s(1));F=distan;----------------------------------------------------------------- %作图:function m=drawTSP(Clist,BSF,bsf,p,f)CityNum=size(Clist,1);for i=1:CityNum-1plot([Clist(BSF(i),1),Clist(BSF(i+1),1)],[Clist(BSF(i),2),Clist(B SF(i+1),2)],'ms-','LineWidth',2,'MarkerEdgeColor','k','MarkerFace Color','g');hold on;endplot([Clist(BSF(CityNum),1),Clist(BSF(1),1)],[Clist(BSF(CityNum), 2),Clist(BSF(1),2)],'ms-','LineWidth',2,'MarkerEdgeColor','k','Ma rkerFaceColor','g');title([num2str(CityNum),'城市TSP']);if f==0text(1.5,1.5,['第',int2str(p),' 步',' 最短距离为',num2str(bsf)]);elsetext(1,1,['最终搜索结果:最短距离 ',num2str(bsf)]);endhold off;pause(0.05)-----------------------------------------------------------------。

遗传算法解决旅行商问题(TSP)

遗传算法解决旅行商问题(TSP)

遗传算法解决旅⾏商问题(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。

遗传算法求解TSP问题

遗传算法求解TSP问题

遗传算法求解TSP问题1、遗传算法前⼀篇遗传算法的基本内容在之前的博客已经应⽤过了之前遗传算法解决的是函数优化问题,即求解最⼤值或最⼩值问题;此次要解决的是组合优化问题中的TSP问题,即旅⾏商问题。

这边先介绍⼀下TSP问题TSP问题(Traveling Salesman Problem),即旅⾏商问题,⼜译为旅⾏推销员问题、货郎担问题,是数学领域中著名问题之⼀。

假设有⼀个旅⾏商⼈要拜访n个城市,他必须选择所要⾛的路径,路径的限制是每个城市只能拜访⼀次,⽽且最后要回到原来出发的城市。

路径的选择⽬标是要求得的路径路程为所有路径之中的最⼩值。

简单地说,TSP问题就是要找到图中的最短哈密尔顿回路,即全局最短路径。

然后遗传算法可以模仿⽣物进化,然后可以找到⼀个近似最优解,但其不⼀定是全局最优解。

2、实验原理1)产⽣初始种群;随机⽣成N个个体作为初始群体popm,随机选择⼀个种群;2)适应度函数;个体评价计算P(t)中各个个体的适应度,遗传算法在进化搜索中基本不利⽤外部信息,仅以适应度函数为依据,利⽤种群中每个个体的适应度值来进⾏搜索。

TSP的⽬标是路径总长度为最短3)选择运算;将使适应度较⼤(优良)个体有较⼤的存在机会,⽽适应度较⼩(低劣)的个体继续存在的机会也较⼩。

简单遗传算法采⽤赌轮选择机制4)交叉运算将交叉算⼦作⽤于群体;5)变异运算将变异算⼦作⽤于群体,并通过以上运算得到下⼀代群体P(t + 1);6)终⽌条件输出解。

3、代码实现1.city.m:随机⽣成N个城市的坐标并保存2.plot_route.m:实现连点画图3.染⾊体的路程代价函数 mylength.m4.适应度函数fit.m5.交叉操作函数 cross.m6.变异函数 Mutation.m7.main函数3、结果分析调整参数并分析运⾏结果(1)对于city_25.mat⽂件中的城市序列,参数ITER=2000,m=2,Pc=0.8,Pm=0.05保持不变,调整种群个数M的值,观察其结果变化:M=50M=100M=500由运⾏结果可知当M=100时得到TSP的最短路径长度均⼩于M=50和M=500运⾏得出的最短路径长度。

遗传算法求解TSP问题的思路

遗传算法求解TSP问题的思路

变异
采用随机多次对换方式,这一方法也要保证 起始点、终点不变。为此,随机对换的位置 不能落在编码第一个和最后一个元素上(即 只能在第 1~n 位之间对换,首末位仍为 0) 。
遗传算法求解 TSP 问题的流程
(3)主函数代码如下:
int main() { TSP point; int i; srand(seed); CalculatDist(); InitColony(point); //生成初始种群 CalFitness(point); //计算适应度 clock_t Begin=clock(); for(i=0;i<Generation;i++) { select_operation(point); //选择 Cross(point,pcross); //交叉 Mutation(point,pmutation); //变异 CalFitness(point); } clock_t end=clock(); OutPut(point); printf("used time:%d\n\n",end-Begin); printf("Please press any key to exit …\n\n"); getchar(); return 0; }
(4)实验结果:
种群中路径适应度的评估
因为目标是求最短路,所以适应度用路径长 度的倒数表示,这样可以保证距离越小,适 应度越大。计算每条路径的适应度,并记录 目前种群中最短径的适应度、遍历顺序、 路径长度、路径编号信息。
选择
群 体 更 新 过 程
采用赌轮的方法选出优良的个体,形成新的 种群。
交叉
采用部分匹配交叉方式,两个父代个体在交 叉后, 形成的子代染色体编码首末位必为 0, 这样做的目的是保证起讫点不变。
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

遗传算法解决TSP问题(C++版)遗传算法流程:交叉,编译,计算适应度,保存最优个体。

其中交叉过程是选择最优的两个染色体进行交叉操作,本文采用的是轮盘赌算法。

#include<iostream>#include<cstdlib>#include<ctime>using namespace std;#define population 200//种群数量#define pc 0.9//交叉的概率#define pm 0.1//变异的概率#define count 200//迭代的次数#define num 10//城市的数量int** city;//存放每个个体的访问顺序int path[10][10] = {//0, 1, 2, 3, 4, 5, 6, 7, 8, 9{ 0, 23, 93, 18, 40, 34, 13, 75, 50, 35 },//0{ 23, 0, 75, 4, 72, 74, 36, 57, 36, 22 },//1{ 93, 75, 0, 64, 21, 73, 51, 25, 74, 89 },//2{ 18, 4, 64, 0, 55, 52, 8, 10, 67, 1 }, //3{ 40, 72, 21, 55, 0, 43, 64, 6, 99, 74 }, //4{ 34, 74, 73, 52, 43, 0, 43, 66, 52, 39 },//5{ 13, 36, 51, 8, 64, 43, 0, 16, 57, 94 },//6{ 75, 57, 25, 10, 6, 66, 16, 0, 23, 11 }, //7{ 50, 36, 74, 67, 99, 52, 57, 23, 0, 42 },//8{ 35, 22, 89, 1, 74, 39, 94, 11, 42, 0 }//9};int* dis;//存放每个个体的访问顺序下的路径长度double* fitness;//存放灭个个体的适应度int min_dis = 1000000;int min_index = -1;int* min_path;//初始化种群void init(){int *a = new int[num];for (int i = 0; i<num; i++){a[i] = i;}city = new int*[population];for (int i = 0; i<population; i++){city[i] = new int[num];}for (int i = 0; i<population; i++){for (int j = num - 1; j >= 0; j--){int n = rand() % (j + 1);//产出的数是0-j,保证交换的后面的数不会再被交换swap(a[j], a[n]);//保证a里面全是0-(num-1)的数,无重复的数,只是顺序颠倒city[i][j] = a[j];}}delete[]a;dis = new int[population];fitness = new double[population];min_path = new int[num];}//计算适应度void compute(){//cout << "do compute now. " << endl;double total = 0;for (int i = 0; i<population; i++){//计算每种情况下,路径的长度dis[i] = 0;int a = city[i][0], b;for (int j = 1; j<num; j++){b = city[i][j];dis[i] += path[a][b];a = b;}dis[i] += path[b][city[i][0]];fitness[i] = 1.0 / dis[i];//以距离的倒数作为适应度函数值total += fitness[i];}}//选择适应度高的物种,采用轮盘赌算法int select(){double total = 0;for (int i = 0; i<population; i++){total += fitness[i];}double size = rand() / (double)RAND_MAX * total;//保证不产生0//cout << "size " << size << endl;double sum = 0;int i = 0;while (sum <= size&&i<population){sum += fitness[++i];}return --i;//返回被选中的个体}int getMinDis(){int result = dis[0];int index = 0;for (int i = 1; i<population; i++){if (result > dis[i]){result = dis[i];index = i;}}return index;}int getMaxDis(){int result = dis[0];int index = 0;for (int i = 1; i<population; i++){if (result < dis[i]){result = dis[i];index = i;}}return index;}void save(){int current_min_index = getMinDis();int current_max_index = getMaxDis();if (dis[current_min_index] < min_dis){min_dis = dis[current_min_index];for (int i = 0; i < num; i++){min_path[i] =city[current_min_index][i];}//cout << "current min dis is: " << min_dis << endl;}else{for (int i = 0; i<num; i++){city[current_max_index][i] = min_path[i];}dis[current_max_index] = min_dis;fitness[current_max_index] = 1.0 / min_dis;}}//最优保存算法bool isExist(int value, int* array, int len){for (int i = 0; i<len; i++){if (value == array[i])return true;}return false;}void convert(int p1, int p2, int* src, int* dst){int len = p2 - p1 + 1;int* temp = new int[len];for (int i = p1; i <= p2; i++){temp[i - p1] = src[i];}int j = (p2 + 1) % num;for (int i = 1; i <= num; i++){int index = (i + p2) % num;if (!isExist(dst[index], temp, len)){dst[j] = dst[index];j = (j + 1) % num;}}for (int i = p1; i <= p2; i++){dst[i] = src[i];}delete[]temp;}//交叉,采用次序交叉算法void cross(){//cout << "do cross now. " << endl;for (int k = 0; k<population; k += 2){int a = select();int b = select();while (a == b){b = select();//保证被选中的个体不是一样的//cout << "same " << b << endl;}//cout << "choose popuilation" << a << " " << b << endl;double p = rand() / double(RAND_MAX);//cout << "cross rate is " << p << endl;int* a1 = new int[num];int* a2 = new int[num];int* b1 = new int[num];int* b2 = new int[num];for (int i = 0; i<num; i++){a1[i] = city[a][i];a2[i] = city[b][i];b1[i] = a2[i];b2[i] = a1[i];}if (p<pc)//满足交叉条件{//选择交叉的两点,并保证p1<p2int p1 = -1;int p2 = -1;while (p1 == p2){p1 = rand() % num;p2 = rand() % num;if (p1>p2){swap(p1, p2);}}//cout << "choose pos " << p1 << " " << p2 << endl;//开始交叉convert(p1, p2, a1, b1);convert(p1, p2, a2, b2);for (int i = 0; i<num; i++){city[k][i] = b1[i];city[k + 1][i] = b2[i];}}else{for (int i = 0; i<num; i++){city[k][i] = a1[i];city[k + 1][i] = a2[i];}}delete[]a1;delete[]a2;delete[]b1;delete[]b2;}}//变异,采用对换操作进行变异void morphis(){//cout << "do morphis now. " << endl;for (int i = 0; i<population; i++){double p = rand() / double(RAND_MAX);//cout << "morphis rate is " << p << endl;if (p<pm)//执行变异{int a = -1, b = -1;while (a == b){a = rand() % num;b = rand() % num;}swap(city[i][a], city[i][b]);}}}int getdis(){//compute();int result = dis[0];int index = 0;for (int i = 1; i<population; i++){if (result > dis[i]){result = dis[i];index = i;}}return result;}//释放申请的数组的空间void dispose(){for (int i = 0; i<population; i++){delete[]city[i];}delete[]city;delete[]dis;delete[]fitness;}int main(){init();//初始化种群int i = 0;srand(time(0));compute();while (i<count){cross();//交叉morphis();//变异compute();//计算适应度save();//保存当前最优的个体//cout << "count " << i++ << endl;cout << getdis() << " ";//输出结果//cout << min_index << " ";if (++i % 10 == 0)cout << endl;}compute();cout << "min distance is: " << min_dis << endl;for (int i = 0; i<num; i++)cout << min_path[i] << " ";cout << endl;dispose();//释放空间return 0;}。

相关文档
最新文档