TSP问题求解实验报告
实验六:遗传算法求解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数据文件格式分析:本次课程设计采用的TSP文件是att48.tsp ,文件是由48组城市坐标构成的,文件共分成三列,第一列为城市编号,第二列为城市横坐标,第三列为城市纵坐标。
数据结构如下所示:实验操作过程:1、TSP文件的读取:class chengshi {int no;double x;double y;chengshi(int no, double x, double y) {this.no = no;this.x = x;this.y = y;}private double getDistance(chengshi chengshi) {return sqrt(pow((x - chengshi.x), 2) + pow((y - chengshi.y), 2));}}try {//定义HashMap保存读取的坐标信息HashMap<Integer, chengshi> map = new HashMap<Integer,chengshi>();//读取文件BufferedReader reader = new BufferedReader(new (new )));for (String str = reader.readLine(); str != null; str = reader.readLine()) { //将读到的信息保存入HashMapif(str.matches("([0-9]+)(\\s*)([0-9]+)(.?)([0-9]*)(\\s*)([0-9]+)(.?)([0-9]*)")) {String[] data = str.split("(\\s+)");chengshi chengshi = new chengshi(Integer.parseInt(data[0]),Double.parseDouble(data[1]),Double.parseDouble(data[2]));map.put(chengshi.no, chengshi);}}//分配距离矩阵存储空间distance = new double[map.size() + 1][map.size() + 1];//分配距离倒数矩阵存储空间heuristic = new double[map.size() + 1][map.size() + 1];//分配信息素矩阵存储空间pheromone = new double[map.size() + 1][map.size() + 1];for (int i = 1; i < map.size() + 1; i++) {for (int j = 1; j < map.size() + 1; j++) {//计算城市间的距离,并存入距离矩阵distance[i][j] = map.get(i).getDistance(map.get(j));//计算距离倒数,并存入距离倒数矩阵heuristic[i][j] = 1 / distance[i][j];//初始化信息素矩阵pheromone[i][j] = 1;}}} catch (Exception exception) {System.out.println("初始化数据失败!");}}2、TSP作图处理:private void evaporatePheromone() {for (int i = 1; i < pheromone.length; i++)for (int j = 1; j < pheromone.length; j++) {pheromone[i][j] *= 1-rate;}}3、关键源代码(带简单的注释):蚂蚁类代码:class mayi {//已访问城市列表private boolean[] visited;//访问顺序表private int[] tour;//已访问城市的个数private int n;//总的距离private double total;mayi() {//给访问顺序表分配空间tour = new int[distance.length+1];//已存入城市数量为n,刚开始为0n = 0;//将起始城市1,放入访问结点顺序表第一项tour[++n] = 1;//给已访问城市结点分配空间visited = new boolean[distance.length];//第一个城市为出发城市,设置为已访问visited[tour[n]] = true;}private int choosechengshi() {//用来random的随机数double m = 0;//获得当前所在的城市号放入j,如果和j相邻的城市没有被访问,那么加入mfor (int i = 1, j = tour[n]; i < pheromone.length; i++) {if (!visited[i]) {m += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);}}//保存随机数double p = m * random();//寻找随机城市double k = 0;//保存城市int q = 0;for (int i = 1, j = tour[n]; k < p; i++) {if (!visited[i]) {k += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);q = i;}}return q;}城市选择代码:private int choosechengshi() {//用来random的随机数double m = 0;//获得当前所在的城市号放入j,如果和j相邻的城市没有被访问,那么加入mfor (int i = 1, j = tour[n]; i < pheromone.length; i++) {if (!visited[i]) {m += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);}}//保存随机数double p = m * random();//寻找随机城市double k = 0;//保存城市int q = 0;for (int i = 1, j = tour[n]; k < p; i++) {if (!visited[i]) {k += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);q = i;}}return q;}4、算法运行收敛图(即运行到第几步,求得的最优值是多少):run:本次为倒数第100次迭代,当前最优路径长度为41634.60本次为倒数第99次迭代,当前最优路径长度为41514.21本次为倒数第98次迭代,当前最优路径长度为38511.61本次为倒数第97次迭代,当前最优路径长度为38511.61本次为倒数第96次迭代,当前最优路径长度为38511.61本次为倒数第95次迭代,当前最优路径长度为38511.61本次为倒数第94次迭代,当前最优路径长度为37293.07、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、本次为倒数第6次迭代,当前最优路径长度为37293.07本次为倒数第5次迭代,当前最优路径长度为37293.07本次为倒数第4次迭代,当前最优路径长度为37293.07本次为倒数第3次迭代,当前最优路径长度为37293.07本次为倒数第2次迭代,当前最优路径长度为37293.07本次为倒数第1次迭代,当前最优路径长度为37293.07得到的最优的路径长度为: 37293.075、最终求得的最优解的TSP图像:最优路径如下:→1→9→38→31→44→18→7→28→37→19→6→30→43→27→17→36→46→33→15→12→11→23→14→25→13→20→47→21→39→32→48→5→29→2→26→4→35→45→10→42→24→34→41→16→22→3→40→8→1成功生成(总时间:3 秒)实验结果分析:本次通过JA V A语言实现蚁群优化算法,我们发现虽然我们找到了问题的最优解,但是最优解的收敛性并不乐观,并不能求得问题的精确解,并且随着参数的调节运行结果有随机性。
基于蚁群优化算法的TSP问题求解计算智能实验报告

智能计算实验报告学院:班级:学号:姓名:成绩:日期:实验名称:基于蚁群优化算法的TSP问题求解题目要求:利用蚁群优化算法对给定的TSP问题进行求解,求出一条最短路径。
蚁群优化算法简介:蚁群算法是一中求解复杂优化问题的启发式算法,该方法通过模拟蚁群对“信息素”的控制和利用进行搜索食物的过程,达到求解最优结果的目的。
它具有智能搜索、全局优化、稳健性强、易于其它方法结合等优点,适应于解决组合优化问题,包括运输路径优化问题。
TSP数据文件格式分析:本次课程设计采用的TSP文件是att48.tsp ,文件是由48组城市坐标构成的,文件共分成三列,第一列为城市编号,第二列为城市横坐标,第三列为城市纵坐标。
数据结构如下所示:实验操作过程:1、TSP文件的读取:class chengshi {int no;double x;double y;chengshi(int no, double x, double y) {this.no = no;this.x = x;this.y = y;}private double getDistance(chengshi chengshi) {return sqrt(pow((x - chengshi.x), 2) + pow((y - chengshi.y), 2));}}try {//定义HashMap保存读取的坐标信息HashMap<Integer, chengshi> map = new HashMap<Integer,chengshi>();//读取文件BufferedReader reader = new BufferedReader(new (new )));for (String str = reader.readLine(); str != null; str = reader.readLine()) { //将读到的信息保存入HashMapif(str.matches("([0-9]+)(\\s*)([0-9]+)(.?)([0-9]*)(\\s*)([0-9]+)(.?)([0-9]*)")) {String[] data = str.split("(\\s+)");chengshi chengshi = new chengshi(Integer.parseInt(data[0]),Double.parseDouble(data[1]),Double.parseDouble(data[2]));map.put(chengshi.no, chengshi);}}//分配距离矩阵存储空间distance = new double[map.size() + 1][map.size() + 1];//分配距离倒数矩阵存储空间heuristic = new double[map.size() + 1][map.size() + 1];//分配信息素矩阵存储空间pheromone = new double[map.size() + 1][map.size() + 1];for (int i = 1; i < map.size() + 1; i++) {for (int j = 1; j < map.size() + 1; j++) {//计算城市间的距离,并存入距离矩阵distance[i][j] = map.get(i).getDistance(map.get(j));//计算距离倒数,并存入距离倒数矩阵heuristic[i][j] = 1 / distance[i][j];//初始化信息素矩阵pheromone[i][j] = 1;}}} catch (Exception exception) {System.out.println("初始化数据失败!");}}2、TSP作图处理:private void evaporatePheromone() {for (int i = 1; i < pheromone.length; i++)for (int j = 1; j < pheromone.length; j++) {pheromone[i][j] *= 1-rate;}}3、关键源代码(带简单的注释):蚂蚁类代码:class mayi {//已访问城市列表private boolean[] visited;//访问顺序表private int[] tour;//已访问城市的个数private int n;//总的距离private double total;mayi() {//给访问顺序表分配空间tour = new int[distance.length+1];//已存入城市数量为n,刚开始为0n = 0;//将起始城市1,放入访问结点顺序表第一项tour[++n] = 1;//给已访问城市结点分配空间visited = new boolean[distance.length];//第一个城市为出发城市,设置为已访问visited[tour[n]] = true;}private int choosechengshi() {//用来random的随机数double m = 0;//获得当前所在的城市号放入j,如果和j相邻的城市没有被访问,那么加入mfor (int i = 1, j = tour[n]; i < pheromone.length; i++) {if (!visited[i]) {m += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);}}//保存随机数double p = m * random();//寻找随机城市double k = 0;//保存城市int q = 0;for (int i = 1, j = tour[n]; k < p; i++) {if (!visited[i]) {k += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);q = i;}}return q;}城市选择代码:private int choosechengshi() {//用来random的随机数double m = 0;//获得当前所在的城市号放入j,如果和j相邻的城市没有被访问,那么加入mfor (int i = 1, j = tour[n]; i < pheromone.length; i++) {if (!visited[i]) {m += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);}}//保存随机数double p = m * random();//寻找随机城市double k = 0;//保存城市int q = 0;for (int i = 1, j = tour[n]; k < p; i++) {if (!visited[i]) {k += pow(pheromone[j][i], alpha) * pow(heuristic[j][i], beta);q = i;}}return q;}4、算法运行收敛图(即运行到第几步,求得的最优值是多少):run:本次为倒数第100次迭代,当前最优路径长度为41634.60本次为倒数第99次迭代,当前最优路径长度为41514.21本次为倒数第98次迭代,当前最优路径长度为38511.61本次为倒数第97次迭代,当前最优路径长度为38511.61本次为倒数第96次迭代,当前最优路径长度为38511.61本次为倒数第95次迭代,当前最优路径长度为38511.61本次为倒数第94次迭代,当前最优路径长度为37293.07、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、本次为倒数第6次迭代,当前最优路径长度为37293.07本次为倒数第5次迭代,当前最优路径长度为37293.07本次为倒数第4次迭代,当前最优路径长度为37293.07本次为倒数第3次迭代,当前最优路径长度为37293.07本次为倒数第2次迭代,当前最优路径长度为37293.07本次为倒数第1次迭代,当前最优路径长度为37293.07得到的最优的路径长度为: 37293.075、最终求得的最优解的TSP图像:最优路径如下:→1→9→38→31→44→18→7→28→37→19→6→30→43→27→17→36→46→33→15→12→11→23→14→25→13→20→47→21→39→32→48→5→29→2→26→4→35→45→10→42→24→34→41→16→22→3→40→8→1成功生成(总时间:3 秒)实验结果分析:本次通过JA V A语言实现蚁群优化算法,我们发现虽然我们找到了问题的最优解,但是最优解的收敛性并不乐观,并不能求得问题的精确解,并且随着参数的调节运行结果有随机性。
TSP问题——实验报告

TSP问题目录1实验目的 (1)2问题描述与分析 (1)3算法分析 (1)3.1回溯法 (1)3.2 动态规划 (1)3.3 模拟退火算法 (2)4程序设计 (2)4.1回溯法 (2)4.2动态规划算法 (3)4.3模拟退火算法 (4)5实验结果及分析 (5)6实验总结 (6)7源代码 (6)1实验目的1.使用搜索方法进行TSP问题的求解2.了解相关智能算法3.了解NP难问题的求解策略2问题描述与分析某售货员要到若干城市去推销商品,已知各城市之间的路程(或旅费)。
他要选定一条从驻地出发,经过每个城市一遍,最后回到驻地的路线,使总的路程(或旅费)最小。
分析:问题的本质是搜索问题,而且这个问题是NP完全问题,问题的复杂度指数增长,所以普通的搜索无法在有限的时间里完成搜索,尽管有各种优化的算法:启发式算法、深度优先搜索、动态规划、回溯等。
都无法改变复杂度。
实际上大多时候人们并不关心NP完全问题的最优解,只要得出一个近似的解就可以了,因此,人们发明了很多算法,例如粒子群算法、遗传算法、模拟退火算法,这一类算法被称为“智能算法”,但是,他们都无法求出最优解,仅能得到近似解,但这已经足够了。
在本次试验中,一共设计了三个算法:回溯法,动态规划,模拟退火算法。
3算法分析3.1回溯法回溯法采用深度优先方式系统地搜索问题的所有解,基本思路是:确定解空间的组织结构之后,从根结点出发,即第一个活结点和第一个扩展结点向纵深方向转移至一个新结点,这个结点成为新的活结点,并成为当前扩展结点。
如果在当前扩展结点处不能再向纵深方向转移,则当前扩展结点成为死结点。
此时,回溯到最近的活结点处,并使其成为当前扩展结点,回溯到以这种工作方式递归地在解空间中搜索,直到找到所求解空间中已经无活结点为止。
旅行商问题的解空间是一棵排列树.对于排列树的回溯搜索与生成1,2,……, n的所有排列的递归算法Perm类似,设开始时x=[ 1,2,… n ],则相应的排列树由x[ 1:n ]的所有排列构成.旅行商问题的回溯算法。
遗传算法求解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;}四、实验结果:。
TSPProblem -

实验一:TSP问题姓名:*班级:*学号:*邮箱:*一、问题描述TSP问题(旅行商问题)是指旅行家要旅行n个城市,要求各个城市经历且仅经历一次然后回到出发城市,并要求所走的路程最短。
此问题可描述如下:设G=(V,E)是一个具有边成本Cij的有向图,Cij的定义如下,对于所有的i和j,Cij>0。
令|V|=n,并假设n>1。
G 的一条周游路线是包含V中每个结点的有向环,周游路线的成本是此路线上所有边的成本和。
二、算法描述旅行商问题要从图G的所有周游路线中求取最小成本的周游路线,而从初始点出发的周游路线一共有(n-1)!条,即等于除初始结点外的n-1个结点的排列数,因此旅行商问题是一个排列问题。
排列问题比子集合的选择问题通常要难于求解得多,这是因为n个物体有n!种排列。
而n个城市有(n-1)!条周游路线,从中找出一条具有最小成本的周游路线的算法,其计算时间显然为O(n!)。
把所有的节点用坐标值表示,用欧式距离的求解方式求出距离矩阵WEIGHT。
把所有节点表示成树的形式,把当前节点表示为根节点,当前节点可到的所有节点表示成其子节点,因为需要求出最优解,所以采用回溯算法来求解。
把所求的最优解表示成一个n元组bestX(N1,N2,…Nn),在求解过程中通过FL来存储当前路径总距离,通过n元组X(N1.N2…)来存储当前所走的路径,在过程中如果发现当前路径CL<FL,把CL的值赋予FL,且回溯。
在回溯过程中没走一次都要判断当前节点是否走过,通过判断节点的值和X组中存储的节点是否相同可以判断节点是否可走。
因为用回溯法求解时间复杂度是O(n!),当节点比较多的时候,需要的量的时间才能求出结果。
所以对回溯算法进行了一些优化。
把贪心算法求出的解当做上界赋予FL,当在某个节点处判断出当前路径距离>FL上界,减去这个分支,此分支后面的节点全部不做判断。
通过贪心算法求出上界,即从初始节点开始,没一都选取当前节点可走的最小距离。
遗传算法求解TSP问题实验报告(仅供参照)

人工智能实验报告实验六遗传算法实验II一、实验目的:熟悉和掌握遗传算法的原理、流程和编码策略,并利用遗传求解函数优化问题,理解求解TSP问题的流程并测试主要参数对结果的影响。
二、实验原理:旅行商问题,即TSP问题(Traveling Salesman Problem)是数学领域中著名问题之一。
假设有一个旅行商人要拜访n个城市,他必须选择所要走的路径,路经的限制是每个城市只能拜访一次,而且最后要回到原来出发的城市。
路径的选择目标是要求得的路径路程为所有路径之中的最小值。
TSP问题是一个组合优化问题。
该问题可以被证明具有NPC计算复杂性。
因此,任何能使该问题的求解得以简化的方法,都将受到高度的评价和关注。
遗传算法的基本思想正是基于模仿生物界遗传学的遗传过程。
它把问题的参数用基因代表,把问题的解用染色体代表(在计算机里用二进制码表示),从而得到一个由具有不同染色体的个体组成的群体。
这个群体在问题特定的环境里生存竞争,适者有最好的机会生存和产生后代。
后代随机化地继承了父代的最好特征,并也在生存环境的控制支配下继续这一过程。
群体的染色体都将逐渐适应环境,不断进化,最后收敛到一族最适应环境的类似个体,即得到问题最优的解。
要求利用遗传算法求解TSP问题的最短路径。
三、实验内容:1、参考实验系统给出的遗传算法核心代码,用遗传算法求解TSP的优化问题,分析遗传算法求解不同规模TSP问题的算法性能。
2、对于同一个TSP问题,分析种群规模、交叉概率和变异概率对算法结果的影响。
3、增加1种变异策略和1种个体选择概率分配策略,比较求解同一TSP问题时不同变异策略及不同个体选择分配策略对算法结果的影响。
4、上交源代码。
四、实验报告要求:1、画出遗传算法求解TSP问题的流程图。
2、分析遗传算法求解不同规模的TSP问题的算法性能。
规模越大,算法的性能越差,所用时间越长。
3、对于同一个TSP问题,分析种群规模、交叉概率和变异概率对算法结果的影响。
分支限界法实验报告

分支限界法实验报告引言分支限界法是一种解决组合优化问题的常用方法,该方法通过对问题空间进行分割,并使用上、下界进行限制,从而快速得到较优解。
在本次实验中,我们主要使用分支限界法解决旅行商问题(TSP),即给定一组城市和各城市之间的距离,求解经过所有城市且距离之和最小的路径。
实验目的本次实验的目的是通过编写程序,利用分支限界法求解旅行商问题,并分析算法的效率和求解结果的优劣。
实验过程问题模型我们使用邻接矩阵来表示城市之间的距离,并通过回溯法和分支限界法来求解最优解。
其中,回溯法用于生成所有可能的路径,而分支限界法则用于剪枝和获取最优解。
在分支限界法中,我们将问题抽象为一个树形结构,树的每个节点代表选择了某一条路径。
同时,我们定义一个上界来限制搜索的范围,并实时更新下界以筛选一些无效的路径。
通过不断剪枝和对路径进行排序,我们最终可以得到最优解。
算法实现我们使用Python语言实现了分支限界法求解旅行商问题的算法。
具体实施步骤如下:步骤1:生成邻接矩阵根据给定的城市和距离,我们首先生成一个邻接矩阵,用于表示各个城市之间的距离。
步骤2:初始化数据结构我们使用一个优先队列来保存当前搜索的路径,并将起始城市加入队列。
同时,我们定义一个全局变量来保存最优路径和当前最优路径的长度。
步骤3:搜索路径通过递归的方式,不断进行路径的搜索。
在搜索过程中,我们使用上、下界和分支限界来进行剪枝操作,并实时更新最优路径信息。
步骤4:输出结果最终,我们得到的最优路径就是旅行商问题的解。
我们将其输出,并统计算法的运行时间。
实验结果实验数据我们使用了一个包含20个城市的实例进行测试,城市之间距离的数据如下:城市距离-1 -2 101 - 3 15... ...19-20 12结果分析经过多次实验,我们得到了最优路径如下:1 -> 3 -> 10 -> 5 -> 17 ->2 -> 12 -> 11 -> 4 -> 9 -> 16 -> 6 -> 19 -> 18-> 13 -> 20 -> 15 -> 8 -> 7 -> 14 -> 1该路径的总距离为123,是经过所有城市且距离之和最小的路径。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
TSP问题求解(一)实验目的熟悉和掌握遗传算法的原理,流程和编码策略,并利用遗传求解函数优化问题,理解求解TSP问题的流程并测试主要参数对结果的影响。
(二)实验原理巡回旅行商问题给定一组n个城市和俩俩之间的直达距离,寻找一条闭合的旅程,使得每个城市刚好经过一次且总的旅行距离最短。
TSP问题也称为货郎担问题,是一个古老的问题。
最早可以追溯到1759年Euler提出的骑士旅行的问题。
1948年,由美国兰德公司推动,TSP成为近代组合优化领域的典型难题。
TSP是一个具有广泛的应用背景和重要理论价值的组合优化问题。
近年来,有很多解决该问题的较为有效的算法不断被推出,例如Hopfield神经网络方法,模拟退火方法以及遗传算法方法等。
TSP搜索空间随着城市数n的增加而增大,所有的旅程路线组合数为(n-1)!/2。
在如此庞大的搜索空间中寻求最优解,对于常规方法和现有的计算工具而言,存在着诸多计算困难。
借助遗传算法的搜索能力解决TSP问题,是很自然的想法。
基本遗传算法可定义为一个8元组:(SGA)=(C,E,P0,M,Φ,Г,Ψ,Τ)C ——个体的编码方法,SGA使用固定长度二进制符号串编码方法;E ——个体的适应度评价函数;P0——初始群体;M ——群体大小,一般取20—100;Ф——选择算子,SGA使用比例算子;Г——交叉算子,SGA使用单点交叉算子;Ψ——变异算子,SGA使用基本位变异算子;Т——算法终止条件,一般终止进化代数为100—500;问题的表示对于一个实际的待优化问题,首先需要将其表示为适合于遗传算法操作的形式。
用遗传算法解决TSP,一个旅程很自然的表示为n个城市的排列,但基于二进制编码的交叉和变异操作不能适用。
路径表示是表示旅程对应的基因编码的最自然,最简单的表示方法。
它在编码,解码,存储过程中相对容易理解和实现。
例如:旅程(5-1-7-8-9-4-6-2-3)可以直接表示为(5 1 7 8 9 4 6 2 3)(三)实验内容N>=8。
随即生成N个城市间的连接矩阵。
指定起始城市。
给出每一代的最优路线和总路线长度。
以代数T作为结束条件,T>=50。
(四)实验代码#include"stdafx.h"#include<stdio.h>#include<string.h>#include<stdlib.h>#include<math.h>#include<time.h>#define cities 10 //城市的个数#define MAXX 100//迭代次数#define pc 0.8 //交配概率#define pm 0.05 //变异概率#define num 10//种群的大小int bestsolution;//最优染色体int distance[cities][cities];//城市之间的距离struct group//染色体的结构{int city[cities];//城市的顺序int adapt;//适应度double p;//在种群中的幸存概率}group[num], grouptemp[num];//随机产生cities个城市之间的相互距离void init(){int i, j;memset(distance, 0, sizeof(distance));srand((unsigned)time(NULL));for (i = 0; i<cities; i++){for (j = i + 1; j<cities; j++){distance[i][j] = rand() % 100;distance[j][i] = distance[i][j];}}//打印距离矩阵printf("城市的距离矩阵如下\n");for (i = 0; i<cities; i++){for (j = 0; j<cities; j++)printf("%4d", distance[i][j]);printf("\n");}}//随机产生初试群void groupproduce(){int i, j, t, k, flag;for (i = 0; i<num; i++) //初始化for (j = 0; j<cities; j++)group[i].city[j] = -1;srand((unsigned)time(NULL));for (i = 0; i<num; i++){//产生10个不相同的数字for (j = 0; j<cities;){t = rand() % cities;flag = 1;for (k = 0; k<j; k++){if (group[i].city[k] == t){flag = 0;break;}}if (flag){group[i].city[j] = t;j++;}}}//打印种群基因printf("初始的种群\n");for (i = 0; i<num; i++){for (j = 0; j<cities; j++)printf("%4d", group[i].city[j]);printf("\n");}}//评价函数,找出最优染色体void pingjia(){int i, j;int n1, n2;int sumdistance, biggestsum = 0;double biggestp = 0;for (i = 0; i<num; i++){sumdistance = 0;for (j = 1; j<cities; j++){n1 = group[i].city[j - 1];n2 = group[i].city[j];sumdistance += distance[n1][n2];}group[i].adapt = sumdistance; //每条染色体的路径总和biggestsum += sumdistance; //种群的总路径}//计算染色体的幸存能力,路劲越短生存概率越大for (i = 0; i<num; i++){group[i].p = 1 - (double)group[i].adapt / (double)biggestsum;biggestp += group[i].p;}for (i = 0; i<num; i++)group[i].p = group[i].p / biggestp; //在种群中的幸存概率,总和为1 //求最佳路劲bestsolution = 0;for (i = 0; i<num; i++)if (group[i].p>group[bestsolution].p)bestsolution = i;//打印适应度for (i = 0; i<num; i++)printf("染色体%d的路径之和与生存概率分别为%4d %.4f\n", i, group[i].adapt, group[i].p);printf("当前种群的最优染色体是%d号染色体\n", bestsolution);}//选择void xuanze(){int i, j, temp;double gradient[num];//梯度概率double xuanze[num];//选择染色体的随机概率int xuan[num];//选择了的染色体//初始化梯度概率for (i = 0; i<num; i++){gradient[i] = 0.0;xuanze[i] = 0.0;}gradient[0] = group[0].p;for (i = 1; i<num; i++)gradient[i] = gradient[i - 1] + group[i].p;srand((unsigned)time(NULL));//随机产生染色体的存活概率for (i = 0; i<num; i++){xuanze[i] = (rand() % 100);xuanze[i] /= 100;}//选择能生存的染色体for (i = 0; i<num; i++){for (j = 0; j<num; j++){if (xuanze[i]<gradient[j]){xuan[i] = j; //第i个位置存放第j个染色体break;}}}//拷贝种群for (i = 0; i<num; i++){grouptemp[i].adapt = group[i].adapt;grouptemp[i].p = group[i].p;for (j = 0; j<cities; j++)grouptemp[i].city[j] = group[i].city[j];}//数据更新for (i = 0; i<num; i++){temp = xuan[i];group[i].adapt = grouptemp[temp].adapt;group[i].p = grouptemp[temp].p;for (j = 0; j<cities; j++)group[i].city[j] = grouptemp[temp].city[j];}//用于测试printf("<------------------------------->\n");for(i=0;i<num;i++){for(j=0;j<cities;j++)printf("%4d",group[i].city[j]);printf("\n");printf("染色体%d的路径之和与生存概率分别为%4d %.4f\n",i,group[i].adapt,group[i].p);}}//交配,对每个染色体产生交配概率,满足交配率的染色体进行交配void jiaopei(){int i, j, k, kk;int t;//参与交配的染色体的个数int point1, point2, temp;//交配断点int pointnum;int temp1, temp2;int map1[cities], map2[cities];double jiaopeip[num];//染色体的交配概率int jiaopeiflag[num];//染色体的可交配情况for (i = 0; i<num; i++)//初始化jiaopeiflag[i] = 0;//随机产生交配概率srand((unsigned)time(NULL));for (i = 0; i<num; i++){jiaopeip[i] = (rand() % 100);jiaopeip[i] /= 100;}//确定可以交配的染色体t = 0;for (i = 0; i<num; i++){if (jiaopeip[i]<pc){jiaopeiflag[i] = 1;t++;}}t = t / 2 * 2;//t必须为偶数//产生t/2个0-9交配断点srand((unsigned)time(NULL));temp1 = 0;//temp1号染色体和temp2染色体交配for (i = 0; i<t / 2; i++){point1 = rand() % cities;point2 = rand() % cities;for (j = temp1; j<num; j++)if (jiaopeiflag[j] == 1){temp1 = j;break;}for (j = temp1 + 1; j<num; j++)if (jiaopeiflag[j] == 1){temp2 = j;break;}//进行基因交配if (point1>point2) //保证point1<=point2{temp = point1;point1 = point2;point2 = temp;}memset(map1, -1, sizeof(map1));memset(map2, -1, sizeof(map2));//断点之间的基因产生映射for (k = point1; k <= point2; k++){map1[group[temp1].city[k]] = group[temp2].city[k];map2[group[temp2].city[k]] = group[temp1].city[k];}//断点两边的基因互换for (k = 0; k<point1; k++){temp = group[temp1].city[k];group[temp1].city[k] = group[temp2].city[k];group[temp2].city[k] = temp;}for (k = point2 + 1; k<cities; k++){temp = group[temp1].city[k];group[temp1].city[k] = group[temp2].city[k];group[temp2].city[k] = temp;}//处理产生的冲突基因for (k = 0; k<point1; k++){for (kk = point1; kk <= point2; kk++)if (group[temp1].city[k] == group[temp1].city[kk]){group[temp1].city[k] = map1[group[temp1].city[k]];break;}}for (k = point2 + 1; k<cities; k++){for (kk = point1; kk <= point2; kk++)if (group[temp1].city[k] == group[temp1].city[kk]){group[temp1].city[k] = map1[group[temp1].city[k]];break;}}for (k = 0; k<point1; k++){for (kk = point1; kk <= point2; kk++)if (group[temp2].city[k] == group[temp2].city[kk]){group[temp2].city[k] = map2[group[temp2].city[k]];break;}}for (k = point2 + 1; k<cities; k++){for (kk = point1; kk <= point2; kk++)if (group[temp2].city[k] == group[temp2].city[kk]){group[temp2].city[k] = map2[group[temp2].city[k]];break;}}temp1 = temp2 + 1;}}//变异void bianyi(){int i, j;int t;int temp1, temp2, point;double bianyip[num]; //染色体的变异概率int bianyiflag[num];//染色体的变异情况for (i = 0; i<num; i++)//初始化bianyiflag[i] = 0;//随机产生变异概率srand((unsigned)time(NULL));for (i = 0; i<num; i++){bianyip[i] = (rand() % 100);bianyip[i] /= 100;}//确定可以变异的染色体t = 0;for (i = 0; i<num; i++){if (bianyip[i]<pm){bianyiflag[i] = 1;t++;}}//变异操作,即交换染色体的两个节点srand((unsigned)time(NULL));for (i = 0; i<num; i++){if (bianyiflag[i] == 1){temp1 = rand() % 10;temp2 = rand() % 10;point = group[i].city[temp1];group[i].city[temp1] = group[i].city[temp2];group[i].city[temp2] = point;}}}int main(){int i, j, t;init();groupproduce();//初始种群评价pingjia();t = 0;while (t++<MAXX){xuanze();//jiaopei();bianyi();pingjia();}//最终种群的评价printf("\n输出最终的种群评价\n");for (i = 0; i<num; i++){for (j = 0; j<cities; j++){printf("%4d", group[i].city[j]);}printf(" adapt:%4d, p:%.4f\n", group[i].adapt, group[i].p);}printf("最优解为%d号染色体\n", bestsolution);system("Pause");}(五)实验结果截图(六)实验心得通过本次实验,使自己对遗传算法有了更进一步的了解。