蚁群算法C

合集下载

蚁群算法

蚁群算法

两阶段算法(Two Phase Algorithm)
算法举例
(3)以P0为起点,以P4为终点,求下图最短路径L
Dijkstra算法 动态规划 L为 P0→P6 → P3 → P4. 总长度为97km。
(4)根据最短路进行分组,最短路由三条分支组成,即
P0→P5 → P8 → P7 → P6 → P0. 33km,5.9t
0 0
4 10 17 0
节约法(Saving Method)
算法举例
点对之间连接的距离节约值
连接点 3-4 2-3 7-8 6-7 1-7 节约里程 19 18 17 16 13 连接点 1-2 1-6 6-8 2-4 1-3 节约里程 12 11 10 9 8 连接点 1-8 2-7 5-8 2-6 4-5 节约里程 5 5 4 3 3 连接点 5-7 3-7 5-6 节约里程 3 1 1
Cij P0 P5 P8 P0 0 P5 8 0 P8 22 18 0 P7 33 29 28 P6 33 29 28 P1 ∞ ∞ 37 P2 ∞ ∞ ∞ P3 ∞ ∞ ∞ P4 ∞ ∞ ∞
P7
P6 P1 P2 P3 P4
0
16
0
25
20 0
35
30 22 0

42 34 30 0

∞ ∞ ∞ 22 0
节约法(Saving Method)
算法举例
求初始解
令Ii={i},i=1,2,· · · ,8;最短路长li=2C0i;载重量ri=Ri;标记 (合并次数)B1=B2=· · · =B8=0.
按节约里程从大到小合并路径 8
P3 P29 10P15 NhomakorabeaP4
11

徐郁蚁群算法求解旅行商问题

徐郁蚁群算法求解旅行商问题

蚁群算法求解旅行商问题1.旅行商问题旅行商问题常被称为旅行推销员问题,是指一名推销员要拜访多个地点时,如何找到在拜访每个地点一次后再回到起点的最短路径。

规则虽然简单,但在地点数目增多后求解却极为复杂。

假设平面上有n个点代表n个城市的位置, 寻找一条最短的闭合路径, 使得可以遍历每一个城市恰好一次。

这就是旅行商问题。

旅行商的路线可以看作是对n个城市所设计的一个环形, 或者是对一列n个城市的排列。

由于对n个城市所有可能的遍历数目可达)!1n个, 因此解决这个问题需要的(计算时间很长。

2.蚁群算法蚁群总是能够发现从蚁巢到食物源的最短路径。

经研究发现,蚂蚁在行走过的路上留下一种挥发性的激素,蚂蚁就是通过这种激素进行信息交流。

蚂蚁趋向于走激素积累较多的路径。

找到最短路径的蚂蚁总是最早返回巢穴,从而在路上留下了较多的激素。

由于最短路径上积累了较多的激素,选择这条路径的蚂蚁就会越来越多,到最后所有的蚂蚁都会趋向于选择这条最短路径。

基于蚂蚁这种行为,人们通过模拟蚂蚁的行为,而提出了一种全局搜索优化的算法,称之为蚁群算法。

3.求解方法假设有n个城市,它们的邻接矩阵为d,其中d代表城市iji到城市j之间的距离。

现也就是找到一个这n个城市的排列,使蚂蚁按这个顺序“旅行”这n个城市,而蚂蚁的行进路程最短。

使用蚁群算法是用一些虚拟的蚂蚁,让它们在这n个城市间“旅行”,如果蚂蚁行进一周后,走的路程较短,则留下较多的信息素,如果蚂蚁走的路程较长,则留下较少的信息素,而蚂蚁更偏向于走信息素多的路径,一段时间后即可找出一条路径。

假设有m只蚂蚁,用η表示边),(j i的能见度,它反映由城ij市i转移到城市j的期望程度,一般取其为d的倒数,即期望ij程度与两城市间的距离成反比;τ表示边),(j i的信息素轨迹强ij度;kτ∆表示蚂蚁k在边),(j i上留下的信息素;k ij p表示处于城ij市i的蚂蚁向城市j的转移概率,其中,城市j是蚂蚁k未访问的城市。

蚁群算法

蚁群算法

基本蚁群算法程序流程图
开始 初始化
循环次数Nc← Nc+1
蚂蚁k=1 蚂蚁k=k+1
按式(1)选择下一元素 修改禁忌表 N Y K≥ m
按式(2)和式(3)进行信息量更新 满足结束条件 Y
Байду номын сангаас输出程序计算结果 结束 N
复杂度分析
对于TSP,所有可行的路径共有(n-1)!/2条,以 此路径比较为基本操作,则需要(n-1)!/2-1次基 本操作才能保证得到绝对最优解。 若1M FLOPS,当n=10, 需要0.19秒 n=20, 需要1929年 n=30, 需要1.4X10e17年
{ ij (t ) | ci , c j C}是t时刻集合C中元素
蚂蚁k(k=1,2,…,m)在运动过程中,根据各条路径上的信息 量决定其转移方向。这里用禁忌表tabuk来记录蚂蚁k当前 所走过的城市,集合随着tabuk进化过程做动态调整。在 搜索过程中,蚂蚁根据各条路径上的信息量及路径的启发 信息来计算状态转移概率。在t时刻蚂蚁k由元素(城市)i 转移到元素(城市)j的状态转移概率:
1) 标有距离的路径图 2) 在0时刻,路径上没有信息素累积,蚂蚁选择路径为任意 3) 在1时刻,路径上信息素堆积,短边信息素多与长边,所以蚂蚁更 倾向于选择ABCDE


(1)其原理是一种正反馈机制或称增强型学习系统;它通过 信息素的不断更新达到最终收敛于最优路径上; (2)它是一种通用型随机优化方法;但人工蚂蚁决不是对实 际蚂蚁的一种简单模拟,它融进了人类的智能; (3)它是一种分布式的优化方法;不仅适合目前的串行计算 机,而且适合未来的并行计算机; (4)它是一种全局优化的方法;不仅可用于求解单目标优化 问题,而且可用于求解多目标优化问题; 2 (5)它是一种启发式算法;计算复杂性为 O( NC m n ),其 中NC 是迭代次数,m 是蚂蚁数目,n 是目的节点数目。

蚁群算法

蚁群算法

4.蚁群算法应用
信息素更新规则
1.蚁群算法简述 2.蚁群算法原理
最大最小蚂蚁系统
3.蚁群算法改进
4.蚁群算法应用
最大最小蚂蚁系统(MAX-MIN Ant System,MMAS)在基本AS算法的基础 上进行了四项改进: (1)只允许迭代最优蚂蚁(在本次迭代构建出最短路径的蚂蚁),或者至今 最优蚂蚁释放信息素。(迭代最优更新规则和至今最优更新规则在MMAS 中会被交替使用)
p( B) 0.033/(0.033 0.3 0.075) 0.081 p(C ) 0.3 /(0.033 0.3 0.075) 0.74 p( D) 0.075 /(0.033 0.3 0.075) 0.18
用轮盘赌法则选择下城市。假设产生的 随机数q=random(0,1)=0.05,则蚂蚁1将会 选择城市B。 用同样的方法为蚂蚁2和3选择下一访问 城市,假设蚂蚁2选择城市D,蚂蚁3选择城 市A。
蚁群算法
1.蚁群算法简述 2.蚁群算法原理 3.蚁群算法改进 4.蚁群算法应用
1.蚁群算法简述 2.蚁群算法原理
3.蚁群算法改进
4.蚁群算法应用


蚁群算法(ant colony optimization, ACO),又称蚂蚁 算法,是一种用来在图中寻找优 化路径的机率型算法。 由Marco Dorigo于1992年在他 的博士论文中提出,其灵感来源 于蚂蚁在寻找食物过程中发现路 径的行为
4.蚁群算法应用
例给出用蚁群算法求解一个四城市的TSP 3 1 2 3 5 4 W dij 1 5 2 2 4 2
假设蚂蚁种群的规模m=3,参数a=1,b=2,r=0.5。 解:
满足结束条件?

蚁群算法的基本原理

蚁群算法的基本原理

蚁群算法的基本原理蚁群算法 (Ant Colony Optimization, ACO) 是一种基于群体智能的优化算法,模拟了蚂蚁在寻找食物时候的行为,被广泛应用于求解组合优化问题、路径规划等领域。

蚁群算法的基本思路蚁群算法的基本思路是通过模拟蚂蚁在寻找食物的过程中释放信息素来获取全局最优解。

具体过程如下:1.初始化信息素: 首先,需要在所有可行解的路径上放置一些信息素。

在开始时,信息素值可以选择为等量的值或一些默认值。

2.蚁群搜索: 一开始,所有的蚂蚁都分别随机选择一个节点作为起点,并开始在网络中搜索。

蚂蚁行动的过程中,会根据路径上信息素浓度的大小来选择下一步的方向。

同时,每只蚂蚁都会记录其所经过的路径和信息素值。

3.信息素更新: 每只蚂蚁到达终点之后,计算其所经过路径的费用,然后根据一定的规则更新路径上的信息素。

较优的路径上将会添加更多的信息素,使下一次蚂蚁选择该路径的概率更大。

4.重复搜索: 重复上面的步骤,直到满足一个停止条件为止。

一种常见的停止条件是达到预定的迭代次数。

蚁群算法的优势蚁群算法在解决组合优化问题时,具有以下的优势:1.全局优化能力极强: 因为每只蚂蚁都只关注自己所经过的路径上的信息素值,所以可以同时搜索并更新多个路径,从而有可能找到全局最优解。

2.能够避免陷入局部最优: 蚁群算法可以通过信息素的挥发、说长存、信息素值的启发式更新等手段来避免陷入局部最优解。

3.易于扩展和并行化: 蚁群算法通常是一种并行的算法,可以很轻松地应用于分布式计算环境中。

蚁群算法的应用蚁群算法在解决组合优化问题、路径规划、调度等方面有着广泛的应用,如下所示:1.旅行商问题: 蚁群算法可以用于解决旅行商问题。

2.线性规划问题: 蚁群算法可以用于求解线性规划问题。

3.路径规划问题: 蚁群算法可以用于车辆路径规划问题。

4.调度问题: 蚁群算法可以用于作业车间调度问题。

蚁群算法是一种基于群体智能的优化算法,模拟了蚂蚁在寻找食物时候的行为。

蚁群算法C

蚁群算法C

这里发个贴吧里面的蚁群算法代码。

// AO.cpp : 定义控制台应用程序的入口点。

#pragma once#include <iostream>#include <math.h>#include <time.h>const double ALPHA=1.0; //启发因子,信息素的重要程度const double BETA=2.0; //期望因子,城市间距离的重要程度const double ROU=0.5; //信息素残留参数const int N_ANT_COUNT=34; //蚂蚁数量const int N_IT_COUNT=1000; //迭代次数const int N_CITY_COUNT=51; //城市数量const double DBQ=100.0; //总的信息素const double DB_MAX=10e9; //一个标志数,10的9次方double g_Trial[N_CITY_COUNT][N_CITY_COUNT]; //两两城市间信息素,就是环境信息素double g_Distance[N_CITY_COUNT][N_CITY_COUNT]; //两两城市间距离//eil51.tsp城市坐标数据double x_Ary[N_CITY_COUNT]={37,49,52,20,40,21,17,31,52,51,42,31,5,12,36,52,27,17,13,57,62,42,16,8,7,27,30,43,58,58,37,38,46,61,62,63,32,45,59,5,10,21,5,30,39,32,25,25,48,56,30};double y_Ary[N_CITY_COUNT]={52,49,64,26,30,47,63,62,33,21,41,32,25,42,16,41,23,33,13,58,42,57,57,52,38,68,48,67,48,27,69,46,10,33,63,69,22,35,15,6,17,10,64,15,10,39,32,55,28,37,40};//返回指定范围内的随机整数int rnd(int nLow,int nUpper){return nLow+(nUpper-nLow)*rand()/(RAND_MAX+1);}//返回指定范围内的随机浮点数double rnd(double dbLow,double dbUpper){double dbTemp=rand()/((double)RAND_MAX+1.0);return dbLow+dbTemp*(dbUpper-dbLow);}//返回浮点数四舍五入取整后的浮点数double ROUND(double dbA){return (double)((int)(dbA+0.5));}//定义蚂蚁类class CAnt{public:CAnt(void);~CAnt(void);public:int m_nPath[N_CITY_COUNT]; //蚂蚁走的路径double m_dbPathLength; //蚂蚁走过的路径长度int m_nAllowedCity[N_CITY_COUNT]; //没去过的城市 int m_nCurCityNo; //当前所在城市编号int m_nMovedCityCount; //已经去过的城市数量public:int ChooseNextCity(); //选择下一个城市void Init(); //初始化void Move(); //蚂蚁在城市间移动void Search(); //搜索路径void CalPathLength(); //计算蚂蚁走过的路径长度};//构造函数CAnt::CAnt(void){}//析构函数CAnt::~CAnt(void){}//初始化函数,蚂蚁搜索前调用void CAnt::Init(){for (int i=0;i<N_CITY_COUNT;i++){m_nAllowedCity[i]=1; //设置全部城市为没有去过 m_nPath[i]=0; //蚂蚁走的路径全部设置为0}//蚂蚁走过的路径长度设置为0m_dbPathLength=0.0;//随机选择一个出发城市m_nCurCityNo=rnd(0,N_CITY_COUNT);//把出发城市保存入路径数组中m_nPath[0]=m_nCurCityNo;//标识出发城市为已经去过了m_nAllowedCity[m_nCurCityNo]=0;//已经去过的城市数量设置为1m_nMovedCityCount=1;}//选择下一个城市//返回值为城市编号int CAnt::ChooseNextCity(){int nSelectedCity=-1; //返回结果,先暂时把其设置为-1//============================================================================ ==//计算当前城市和没去过的城市之间的信息素总和double dbTotal=0.0;double prob[N_CITY_COUNT]; //保存各个城市被选中的概率for (int i=0;i<N_CITY_COUNT;i++){if (m_nAllowedCity[i] == 1) //城市没去过{prob[i]=pow(g_Trial[m_nCurCityNo][i],ALPHA)*pow(1.0/g_Distance[m_nCurCityNo][i],BET A); //该城市和当前城市间的信息素dbTotal=dbTotal+prob[i]; //累加信息素,得到总和}else //如果城市去过了,则其被选中的概率值为0{prob[i]=0.0;}}//============================================================================ ==//进行轮盘选择double dbTemp=0.0;if (dbTotal > 0.0) //总的信息素值大于0{dbTemp=rnd(0.0,dbTotal); //取一个随机数for (int i=0;i<N_CITY_COUNT;i++){if (m_nAllowedCity[i] == 1) //城市没去过{dbTemp=dbTemp-prob[i]; //这个操作相当于转动轮盘,如果对轮盘选择不熟悉,仔细考虑一下if (dbTemp < 0.0) //轮盘停止转动,记下城市编号,直接跳出循环{nSelectedCity=i;break;}}}}//============================================================================ ==//如果城市间的信息素非常小( 小到比double能够表示的最小的数字还要小)//那么由于浮点运算的误差原因,上面计算的概率总和可能为0//会出现经过上述操作,没有城市被选择出来//出现这种情况,就把第一个没去过的城市作为返回结果//题外话:刚开始看的时候,下面这段代码困惑了我很长时间,想不通为何要有这段代码,后来才搞清楚。

蚁群算法及案例分析

蚁群算法及案例分析
问过的节点;另外,人工蚁
群在选择下一条路径的时
候并不是完全盲目的,而是
按一定的算法规律有意识
地寻找最短路径
自然界蚁群不具有记忆的
能力,它们的选路凭借外
激素,或者道路的残留信
息来选择,更多地体现正
反馈的过程
人工蚁群和自然界蚁群的相似之处在于,两者优先选择的都
是含“外激素”浓度较大的路径; 两者的工作单元(蚂蚁)都
Eta=1./D;
%Eta为启发因子,这里设为距离的倒数
Tau=ones(n,n);
%Tau为信息素矩阵
Tabu=zeros(m,n);
%存储并记录路径的生成
NC=1;
%迭代计数器
R_best=zeros(NC_max,n); %各代最佳路线
L_best=inf.*ones(NC_max,1);%各代最佳路线的长度
for ii=2:N
R_best(NC,:)=Tabu(pos(1),:);
plot([C(R(ii-1),1),C(R(ii),1)],[C(R(ii-1),2),C(R(ii),2)])
L_ave(NC)=mean(L);
hold on
NC=NC+1;
end
%第五步:更新信息素
Delta_Tau=zeros(n,n);
, 表示可根据由城市i到城市j的期望程度,可根据启发式算法具体确定,

一般为 。

= 0,算法演变成传统的随机贪婪算法最邻近城市被选中概率最大
= 0,蚂蚁完全只根据信息度浓度确定路径,算法将快速收敛,这样构出
的路径与实际目标有着较大的差距,实验表明在AS中设置α=1~2,β=2~5比较合
DrawRoute(C,Shortest_Route)

人工蜂群算法和蚁群算法

人工蜂群算法和蚁群算法

人工蜂群算法和蚁群算法人工蜂群算法(Artificial Bee Colony Algorithm,简称ABC 算法)和蚁群算法(Ant Colony Algorithm,简称ACA)都是基于自然界中生物行为的启发式搜索算法。

它们在解决优化问题方面具有较强的通用性,被广泛应用于工程、自然科学和社会科学等多个领域。

一、人工蜂群算法(ABC算法)人工蜂群算法是由土耳其学者Karaboga于2005年首次提出,灵感来源于蜜蜂寻找花蜜的过程。

该算法通过模拟蜜蜂的搜索行为来寻找最优解。

算法步骤:1. 初始化一群蜜蜂,每个蜜蜂代表一个潜在的解决方案。

2. 蜜蜂根据蜂王释放的信息素和自己的飞行经验,选择下一个搜索位置。

3. 评估每个位置的花蜜量(即解的质量)。

4. 根据花蜜量和蜜罐位置更新信息素。

5. 经过多次迭代,直至满足终止条件,如达到最大迭代次数或找到满足要求的解。

二、蚁群算法(ACA)蚁群算法是由意大利学者Dorigo、Maniezzo和Colorni于1992年提出的,灵感来源于蚂蚁在寻找食物过程中释放信息素并利用这种信息素找到最优路径的行为。

算法步骤:1. 初始化一群蚂蚁,每个蚂蚁随机选择一个节点开始搜索。

2. 蚂蚁在选择下一个节点时,会根据当前节点的信息素浓度和启发函数(如距离的倒数)来计算转移概率。

3. 每只蚂蚁遍历整个问题空间,留下路径上的信息素。

4. 信息素随时间蒸发,蚂蚁的路径越短,信息素蒸发得越慢。

5. 经过多次迭代,直至满足终止条件,如达到最大迭代次数或找到满足要求的解。

三、比较原理不同:ABC算法基于蜜蜂的搜索行为,而ACA基于蚂蚁的信息素觅食行为。

应用领域:ABC算法适用于连续优化问题,而ACA在组合优化问题中应用更为广泛。

参数调整:ABC算法的参数较少,调整相对容易;ACA的参数较多,调整和优化难度较大。

局部搜索能力:ABC算法具有较强的局部搜索能力;ACA通过信息素的蒸发和更新,能够避免早熟收敛。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

// AO.cpp : 定义控制台应用程序的入口点。

#pragma once#include <iostream>#include <math.h>#include <time.h>const double ALPHA=1.0; //启发因子,信息素的重要程度const double BETA=2.0; //期望因子,城市间距离的重要程度const double ROU=0.5; //信息素残留参数const int N_ANT_COUNT=34; //蚂蚁数量const int N_IT_COUNT=1000; //迭代次数const int N_CITY_COUNT=51; //城市数量const double DBQ=100.0; //总的信息素const double DB_MAX=10e9; //一个标志数,10的9次方double g_Trial[N_CITY_COUNT][N_CITY_COUNT]; //两两城市间信息素,就是环境信息素double g_Distance[N_CITY_COUNT][N_CITY_COUNT]; //两两城市间距离//eil51.tsp城市坐标数据double x_Ary[N_CITY_COUNT]={37,49,52,20,40,21,17,31,52,51,42,31,5,12,36,52,27,17,13,57,62,42,16,8,7,27,30,43,58,58,37,38,46,61,62,63,32,45,59,5,10,21,5,30,39,32,25,25,48,56,30};double y_Ary[N_CITY_COUNT]={52,49,64,26,30,47,63,62,33,21,41,32,25,42,16,41,23,33,13,58,42,57,57,52,38,68,48,67,48,27,69,46,10,33,63,69,22,35,15,6,17,10,64,15,10,39,32,55,28,37,40};//返回指定范围内的随机整数int rnd(int nLow,int nUpper){return nLow+(nUpper-nLow)*rand()/(RAND_MAX+1);}//返回指定范围内的随机浮点数double rnd(double dbLow,double dbUpper){double dbTemp=rand()/((double)RAND_MAX+1.0);return dbLow+dbTemp*(dbUpper-dbLow);}//返回浮点数四舍五入取整后的浮点数double ROUND(double dbA){return (double)((int)(dbA+0.5));}//定义蚂蚁类class CAnt{public:CAnt(void);~CAnt(void);public:int m_nPath[N_CITY_COUNT]; //蚂蚁走的路径double m_dbPathLength; //蚂蚁走过的路径长度int m_nAllowedCity[N_CITY_COUNT]; //没去过的城市 int m_nCurCityNo; //当前所在城市编号int m_nMovedCityCount; //已经去过的城市数量public:int ChooseNextCity(); //选择下一个城市void Init(); //初始化void Move(); //蚂蚁在城市间移动void Search(); //搜索路径void CalPathLength(); //计算蚂蚁走过的路径长度};//构造函数CAnt::CAnt(void){}//析构函数CAnt::~CAnt(void){}//初始化函数,蚂蚁搜索前调用void CAnt::Init(){for (int i=0;i<N_CITY_COUNT;i++){m_nAllowedCity[i]=1; //设置全部城市为没有去过 m_nPath[i]=0; //蚂蚁走的路径全部设置为0}//蚂蚁走过的路径长度设置为0m_dbPathLength=0.0;//随机选择一个出发城市m_nCurCityNo=rnd(0,N_CITY_COUNT);//把出发城市保存入路径数组中m_nPath[0]=m_nCurCityNo;//标识出发城市为已经去过了m_nAllowedCity[m_nCurCityNo]=0;//已经去过的城市数量设置为1m_nMovedCityCount=1;}//选择下一个城市//返回值为城市编号int CAnt::ChooseNextCity(){int nSelectedCity=-1; //返回结果,先暂时把其设置为-1//============================================================================ ==//计算当前城市和没去过的城市之间的信息素总和double dbTotal=0.0;double prob[N_CITY_COUNT]; //保存各个城市被选中的概率for (int i=0;i<N_CITY_COUNT;i++){if (m_nAllowedCity[i] == 1) //城市没去过{prob[i]=pow(g_Trial[m_nCurCityNo][i],ALPHA)*pow(1.0/g_Distance[m_nCurCityNo][i],BET A); //该城市和当前城市间的信息素dbTotal=dbTotal+prob[i]; //累加信息素,得到总和}else //如果城市去过了,则其被选中的概率值为0{prob[i]=0.0;}}//============================================================================ ==//进行轮盘选择double dbTemp=0.0;if (dbTotal > 0.0) //总的信息素值大于0{dbTemp=rnd(0.0,dbTotal); //取一个随机数for (int i=0;i<N_CITY_COUNT;i++){if (m_nAllowedCity[i] == 1) //城市没去过{dbTemp=dbTemp-prob[i]; //这个操作相当于转动轮盘,如果对轮盘选择不熟悉,仔细考虑一下if (dbTemp < 0.0) //轮盘停止转动,记下城市编号,直接跳出循环{nSelectedCity=i;break;}}}}//============================================================================ ==//如果城市间的信息素非常小( 小到比double能够表示的最小的数字还要小)//那么由于浮点运算的误差原因,上面计算的概率总和可能为0//会出现经过上述操作,没有城市被选择出来//出现这种情况,就把第一个没去过的城市作为返回结果//题外话:刚开始看的时候,下面这段代码困惑了我很长时间,想不通为何要有这段代码,后来才搞清楚。

if (nSelectedCity == -1){for (int i=0;i<N_CITY_COUNT;i++){if (m_nAllowedCity[i] == 1) //城市没去过{nSelectedCity=i;break;}}}//============================================================================ ==//返回结果,就是城市的编号return nSelectedCity;}//蚂蚁在城市间移动void CAnt::Move(){int nCityNo=ChooseNextCity(); //选择下一个城市m_nPath[m_nMovedCityCount]=nCityNo; //保存蚂蚁走的路径m_nAllowedCity[nCityNo]=0;//把这个城市设置成已经去过了m_nCurCityNo=nCityNo; //改变当前所在城市为选择的城市m_nMovedCityCount++; //已经去过的城市数量加1}//蚂蚁进行搜索一次void CAnt::Search(){Init(); //蚂蚁搜索前,先初始化//如果蚂蚁去过的城市数量小于城市数量,就继续移动while (m_nMovedCityCount < N_CITY_COUNT){Move();}//完成搜索后计算走过的路径长度CalPathLength();}//计算蚂蚁走过的路径长度void CAnt::CalPathLength(){m_dbPathLength=0.0; //先把路径长度置0int m=0;int n=0;for (int i=1;i<N_CITY_COUNT;i++){m=m_nPath[i];n=m_nPath[i-1];m_dbPathLength=m_dbPathLength+g_Distance[m][n];}//加上从最后城市返回出发城市的距离n=m_nPath[0];m_dbPathLength=m_dbPathLength+g_Distance[m][n];}//tsp类class CTsp{public:CTsp(void);~CTsp(void);public:CAnt m_cAntAry[N_ANT_COUNT]; //蚂蚁数组CAnt m_cBestAnt; //定义一个蚂蚁变量,用来保存搜索过程中的最优结果 //该蚂蚁不参与搜索,只是用来保存最优结果public://初始化数据void InitData();//开始搜索void Search();//更新环境信息素void UpdateTrial();};//构造函数CTsp::CTsp(void){}CTsp::~CTsp(void){}//初始化数据void CTsp::InitData(){//先把最优蚂蚁的路径长度设置成一个很大的值m_cBestAnt.m_dbPathLength=DB_MAX;//计算两两城市间距离double dbTemp=0.0;for (int i=0;i<N_CITY_COUNT;i++){for (int j=0;j<N_CITY_COUNT;j++){dbTemp=(x_Ary[i]-x_Ary[j])*(x_Ary[i]-x_Ary[j])+(y_Ary[i]-y_Ary[j])*(y_Ary[i]-y_Ary[j]); dbTemp=pow(dbTemp,0.5);g_Distance[i][j]=ROUND(dbTemp);}}//初始化环境信息素,先把城市间的信息素设置成一样//这里设置成1.0,设置成多少对结果影响不是太大,对算法收敛速度有些影响for (int i=0;i<N_CITY_COUNT;i++){for (int j=0;j<N_CITY_COUNT;j++){g_Trial[i][j]=1.0;}}}//更新环境信息素void CTsp::UpdateTrial(){//临时数组,保存各只蚂蚁在两两城市间新留下的信息素double dbTempAry[N_CITY_COUNT][N_CITY_COUNT];memset(dbTempAry,0,sizeof(dbTempAry)); //先全部设置为0//计算新增加的信息素,保存到临时数组里int m=0;int n=0;for (int i=0;i<N_ANT_COUNT;i++) //计算每只蚂蚁留下的信息素{for (int j=1;j<N_CITY_COUNT;j++){m=m_cAntAry[i].m_nPath[j];n=m_cAntAry[i].m_nPath[j-1];dbTempAry[n][m]=dbTempAry[n][m]+DBQ/m_cAntAry[i].m_dbPathLength;dbTempAry[m][n]=dbTempAry[n][m];}//最后城市和开始城市之间的信息素n=m_cAntAry[i].m_nPath[0];dbTempAry[n][m]=dbTempAry[n][m]+DBQ/m_cAntAry[i].m_dbPathLength;dbTempAry[m][n]=dbTempAry[n][m];}//==================================================================//更新环境信息素for (int i=0;i<N_CITY_COUNT;i++){for (int j=0;j<N_CITY_COUNT;j++){g_Trial[i][j]=g_Trial[i][j]*ROU+dbTempAry[i][j]; //最新的环境信息素= 留存的信息素+ 新留下的信息素}}}void CTsp::Search(){char cBuf[256]; //打印信息用//在迭代次数内进行循环for (int i=0;i<N_IT_COUNT;i++){//每只蚂蚁搜索一遍for (int j=0;j<N_ANT_COUNT;j++){m_cAntAry[j].Search();}//保存最佳结果for (int j=0;j<N_ANT_COUNT;j++){if (m_cAntAry[j].m_dbPathLength < m_cBestAnt.m_dbPathLength) {m_cBestAnt=m_cAntAry[j];}}//更新环境信息素UpdateTrial();//输出目前为止找到的最优路径的长度sprintf(cBuf,"\n[%d] %.0f",i+1,m_cBestAnt.m_dbPathLength);printf(cBuf);}}int main(){//用当前时间点初始化随机种子,防止每次运行的结果都相同time_t tm;time(&tm);unsigned int nSeed=(unsigned int)tm;srand(nSeed);//开始搜索CTsp tsp;tsp.InitData(); //初始化tsp.Search(); //开始搜索//输出结果printf("\nThe best tour is :\n");char cBuf[128];for (int i=0;i<N_CITY_COUNT;i++){sprintf(cBuf,"d ",tsp.m_cBestAnt.m_nPath[i]+1);if (i % 20 == 0){printf("\n");}printf(cBuf);}printf("\n\nPress any key to exit!");getchar();return 0;}。

相关文档
最新文档