下载文档原格式
蚁群算法内容简介蚁群算法(ant colony optimization, ACO)，又称蚂蚁算法，是一种用来在图中寻找优化路径的机率型算法群算法是由意大利学者Dorigo等人于20世纪90年代初期通过模拟自然界中蚂蚁集体寻经的行为而提出的一种基于种群的启发式随机搜索算法，蚁群算法具有并行性、鲁棒性、正反馈性等特点。
蚁群算法最早成功应用于解决著名的旅行商问题以及二次分配问题、车间任务调度问题、图的着色问题、网络路由等许多复杂的组合问题。
蚁群算法是一种模拟进化算法,初步的研究表明该算法具有许多优良的性质.针对PID控制器参数优化设计问题,将蚁群算法设计的结果与遗传算法设计的结果进行了比较,数值仿真结果表明,蚁群算法具有一种新的模拟进化优化方法的有效性和应用价值。
随着人们对效益的要求越来越高，人们发现组合优化的各种方法，但在一些复杂度比较高的问题上，一些传统的方法显示了他的限制，列如计算量上升太快，时间复杂度很高，这就需要一些新的方法来解决这些问题，从而有效地克服传统蚁群算法中容易陷入局部最优解和收敛速度慢的现象。
蚁群系统(Ant Colony System)，这种算法是目前国内外启发式算法中的研究热点和前沿课题，被成功地运用于旅行商问题的求解，蚁群算法在求解复杂优化问题方面具有很大的优越性和广阔的前景。
但是,根据观察实验发现，蚁群中的多个蚂蚁的运动是随机的，在扩散范围较大时，在较短时间内很难找出一条较好的路径，在算法实现的过程中容易出现停滞现象和收敛速度慢现象。
在这种弊端的情况下，学者们提出了一种自适应蚁群算法，通过自适应地调整运行过程中的挥发因子来改变路径中信息素浓度,从而有效地克服传统蚁群算法中容易陷入局部最优解和收敛速度慢的现象。
下面是一些最常用的变异蚁群算法精英蚂蚁系统全局最优解决方案在每个迭代以及其他所有的蚂蚁的沉积信息素。
最大最小蚂蚁系统（MMAS）添加的最大和最小的信息素量[ τmax ，τmin ]，只有全局最佳或迭代最好的巡逻沉积的信息素。
蚁群算法概述一、蚁群算法蚁群算法(ant colony optimization, ACO)，又称蚂蚁算法，是一种用来寻找最优解决方案的机率型技术。
它由Marco Dorigo于1992年在他的博士论文中引入，其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。
蚂蚁在路径上前进时会根据前边走过的蚂蚁所留下的分泌物选择其要走的路径。
其选择一条路径的概率与该路径上分泌物的强度成正比。
因此，由大量蚂蚁组成的群体的集体行为实际上构成一种学习信息的正反馈现象：某一条路径走过的蚂蚁越多，后面的蚂蚁选择该路径的可能性就越大。
蚂蚁的个体间通过这种信息的交流寻求通向食物的最短路径。
蚁群算法就是根据这一特点，通过模仿蚂蚁的行为，从而实现寻优。
这种算法有别于传统编程模式，其优势在于，避免了冗长的编程和筹划，程序本身是基于一定规则的随机运行来寻找最佳配置。
也就是说，当程序最开始找到目标的时候，路径几乎不可能是最优的，甚至可能是包含了无数错误的选择而极度冗长的。
但是，程序可以通过蚂蚁寻找食物的时候的信息素原理，不断地去修正原来的路线，使整个路线越来越短，也就是说，程序执行的时间越长，所获得的路径就越可能接近最优路径。
这看起来很类似与我们所见的由无数例子进行归纳概括形成最佳路径的过程。
实际上好似是程序的一个自我学习的过程。
3、人工蚂蚁和真实蚂蚁的异同ACO是一种基于群体的、用于求解复杂优化问题的通用搜索技术。
与真实蚂蚁通过外激素的留存/跟随行为进行间接通讯相似，ACO中一群简单的人工蚂蚁（主体）通过信息素（一种分布式的数字信息，与真实蚂蚁释放的外激素相对应）进行间接通讯，并利用该信息和与问题相关的启发式信息逐步构造问题的解。
人工蚂蚁具有双重特性：一方面，他们是真实蚂蚁的抽象，具有真实蚂蚁的特性，另一方面，他们还有一些在真实蚂蚁中找不到的特性，这些新的特性，使人工蚂蚁在解决实际优化问题时，具有更好地搜索较好解的能力。
人工蚂蚁与真实蚂蚁的相同点为：1．都是一群相互协作的个体。
蚁群算法⼀、蚁群算法简介 蚁群算法(AG)是⼀种模拟蚂蚁觅⾷⾏为的模拟优化算法，它是由意⼤利学者Dorigo M等⼈于1991年⾸先提出，并⾸先使⽤在解决TSP（旅⾏商问题）上。
之后，⼜系统研究了蚁群算法的基本原理和数学模型.⼆、蚁群算法原理1、蚂蚁在路径上释放信息素。
2、碰到还没⾛过的路⼝，就随机挑选⼀条路⾛。
同时，释放与路径长度有关的信息素。
3、信息素浓度与路径长度成反⽐。
后来的蚂蚁再次碰到该路⼝时，就选择信息素浓度较⾼路径。
4、最优路径上的信息素浓度越来越⼤。
5、最终蚁群找到最优寻⾷路径。
三、蚁群算法流程图四、实例应⽤基于TSP问题的基本蚁群算法原理讲解参考⽼师上课讲解的PPT不做过多粘贴1.源代码：%% 旅⾏商问题(TSP)优化%% 清空环境变量clear allclc%% 导⼊数据citys = ceil(rand(50,2)*50000)%load newcitys.mat%% 计算城市间相互距离fprintf('Computing Distance Matrix... \n');n = size(citys,1);D = zeros(n,n);for i = 1:nfor j = 1:nif i ~= jD(i,j) = sqrt(sum((citys(i,:) - citys(j,:)).^2));elseD(i,j) = 1e-4;endendend%% 初始化参数fprintf('Initializing Parameters... \n');m = 50; % 蚂蚁数量alpha = 1; % 信息素重要程度因⼦beta = 5; % 启发函数重要程度因⼦rho = 0.05; % 信息素挥发因⼦Q = 1; % 常系数Eta = 1./D; % 启发函数Tau = ones(n,n); % 信息素矩阵Table = zeros(m,n); % 路径记录表iter = 1; % 迭代次数初值iter_max = 150; % 最⼤迭代次数Route_best = zeros(iter_max,n); % 各代最佳路径Length_best = zeros(iter_max,1); % 各代最佳路径的长度Length_ave = zeros(iter_max,1); % 各代路径的平均长度%% 迭代寻找最佳路径figure;while iter <= iter_maxfprintf('迭代第%d次\n',iter);% 随机产⽣各个蚂蚁的起点城市start = zeros(m,1);for i = 1:mtemp = randperm(n);start(i) = temp(1);endTable(:,1) = start;% 构建解空间citys_index = 1:n;% 逐个蚂蚁路径选择for i = 1:m% 逐个城市路径选择for j = 2:ntabu = Table(i,1:(j - 1)); % 已访问的城市集合(禁忌表)allow_index = ~ismember(citys_index,tabu);allow = citys_index(allow_index); % 待访问的城市集合P = allow;% 计算城市间转移概率for k = 1:length(allow)P(k) = Tau(tabu(end),allow(k))^alpha * Eta(tabu(end),allow(k))^beta; endP = P/sum(P);% 轮盘赌法选择下⼀个访问城市Pc = cumsum(P);target_index = find(Pc >= rand);target = allow(target_index(1));Table(i,j) = target;endend% 计算各个蚂蚁的路径距离Length = zeros(m,1);for i = 1:mRoute = Table(i,:);for j = 1:(n - 1)Length(i) = Length(i) + D(Route(j),Route(j + 1));endLength(i) = Length(i) + D(Route(n),Route(1));end% 计算最短路径距离及平均距离if iter == 1[min_Length,min_index] = min(Length);Length_best(iter) = min_Length;Length_ave(iter) = mean(Length);Route_best(iter,:) = Table(min_index,:);else[min_Length,min_index] = min(Length);Length_best(iter) = min(Length_best(iter - 1),min_Length);Length_ave(iter) = mean(Length);if Length_best(iter) == min_LengthRoute_best(iter,:) = Table(min_index,:);elseRoute_best(iter,:) = Route_best((iter-1),:);endend% 更新信息素Delta_Tau = zeros(n,n);% 逐个蚂蚁计算for i = 1:m% 逐个城市计算for j = 1:(n - 1)Delta_Tau(Table(i,j),Table(i,j+1)) = Delta_Tau(Table(i,j),Table(i,j+1)) + Q/Length(i); endDelta_Tau(Table(i,n),Table(i,1)) = Delta_Tau(Table(i,n),Table(i,1)) + Q/Length(i); endTau = (1-rho) * Tau + Delta_Tau;% 迭代次数加1，清空路径记录表% figure;%最佳路径的迭代变化过程[Shortest_Length,index] = min(Length_best(1:iter));Shortest_Route = Route_best(index,:);plot([citys(Shortest_Route,1);citys(Shortest_Route(1),1)],...[citys(Shortest_Route,2);citys(Shortest_Route(1),2)],'o-');pause(0.3);iter = iter + 1;Table = zeros(m,n);% endend%% 结果显⽰[Shortest_Length,index] = min(Length_best);Shortest_Route = Route_best(index,:);disp(['最短距离:' num2str(Shortest_Length)]);disp(['最短路径:' num2str([Shortest_Route Shortest_Route(1)])]);%% 绘图figure(1)plot([citys(Shortest_Route,1);citys(Shortest_Route(1),1)],...[citys(Shortest_Route,2);citys(Shortest_Route(1),2)],'o-');grid onfor i = 1:size(citys,1)text(citys(i,1),citys(i,2),[' ' num2str(i)]);endtext(citys(Shortest_Route(1),1),citys(Shortest_Route(1),2),' 起点');text(citys(Shortest_Route(end),1),citys(Shortest_Route(end),2),' 终点');xlabel('城市位置横坐标')ylabel('城市位置纵坐标')title(['蚁群算法优化路径(最短距离:' num2str(Shortest_Length) ')'])figure(2)plot(1:iter_max,Length_best,'b',1:iter_max,Length_ave,'r:')legend('最短距离','平均距离')xlabel('迭代次数')ylabel('距离')title('各代最短距离与平均距离对⽐')运⾏结果：利⽤函数citys = ceil(rand(50,2)*50000) 随机产⽣五⼗个城市坐标2.研究信息素重要程度因⼦alpha, 启发函数重要程度因⼦beta,信息素挥发因⼦rho对结果的影响为了保证变量唯⼀我重新设置五⼗个城市信息进⾏实验在原来设值运⾏结果：实验结果可知当迭代到120次趋于稳定2.1 alpha值对实验结果影响（1）当alpha=4时运⾏结果实验结果可知当迭代到48次左右趋于稳定（2）当alpha=8时运⾏结果：有图可知迭代40次左右趋于稳定，搜索性较⼩（3）当alpha= 0.5运⾏结果：有图可知迭代到140次左右趋于稳定（4）当alpha=0.2时运⾏结果：结果趋于110次左右稳定所以如果信息素因⼦值设置过⼤，则容易使随机搜索性减弱；其值过⼩容易过早陷⼊局部最优2.2 beta值对实验影响（1）当 beta=8时运⾏结果结果迭代75次左右趋于稳定（2）当 beta=1时运⾏结果：结果迭代130次左右趋于稳定所以beta如果值设置过⼤，虽然收敛速度加快，但是易陷⼊局部最优；其值过⼩，蚁群易陷⼊纯粹的随机搜索，很难找到最优解2.3 rho值对实验结果影响(1)当rho=3时运⾏结果：结果迭代75次左右趋于稳定（2）当rho=0.05运⾏结果：结果迭代125次左右趋于稳定所以如果rho取值过⼤时，容易影响随机性和全局最优性；反之，收敛速度降低总结：蚁群算法对于参数的敏感程度较⾼，参数设置的好，算法的结果也就好，参数设置的不好则运⾏结果也就不好，所以通常得到的只是局部最优解。
蚁群算法简介蚁群算法是一种优化技术，受到自然界中蚂蚁寻找食物的行为的启发。
这种算法模拟了蚂蚁的信息共享和移动模式，用于解决复杂的组合优化问题，如旅行商问题（TSP）、车辆路径问题（VRP）等。
一、蚁群算法的基本原理在自然界中，蚂蚁寻找食物的行为非常有趣。
它们会在路径上留下信息素，后续的蚂蚁会根据信息素的强度选择路径，倾向于选择信息素浓度高的路径。
这样，一段时间后，大多数蚂蚁都会选择最短或最佳的路径。
这就是蚁群算法的基本原理。
二、蚁群算法的主要步骤1.初始化：首先，为每条边分配一个初始的信息素浓度。
通常，所有边的初始信息素浓度都是相等的。
2.路径选择：在每一步，每个蚂蚁都会根据当前位置和周围信息素浓度选择下一步的移动方向。
选择概率与信息素浓度成正比，与距离成反比。
这意味着蚂蚁更倾向于选择信息素浓度高且距离短的路径。
3.释放信息素：当蚂蚁完成一次完整的路径后，它会在其经过的边上留下信息素。
信息素的浓度与解决问题的质量成正比，即如果蚂蚁找到了一条更好的路径，那么这条路径上的信息素浓度会增加。
4.更新：经过一段时间后，信息素会随时间的推移而挥发，这使得那些不再被认为是最优的路径上的信息素浓度逐渐减少。
同时，每条边上的信息素浓度也会随着时间的推移而均匀增加，这使得那些从未被探索过的路径也有被选择的可能性。
5.终止条件：算法会在找到满足条件的最优解或达到预设的最大迭代次数后终止。
三、蚁群算法的优势和局限性蚁群算法的优势在于其对于组合优化问题的良好性能和其自然启发式的搜索过程。
这种算法能够有效地找到全局最优解，并且在搜索过程中能够避免陷入局部最优解。
此外，蚁群算法具有较强的鲁棒性，对于问题的规模和复杂性具有较强的适应性。
然而，蚁群算法也存在一些局限性。
首先，算法的性能高度依赖于参数的设置，如信息素的挥发速度、蚂蚁的数量、迭代次数等。
其次，对于一些复杂的问题，可能需要很长的计算时间才能找到最优解。
此外，蚁群算法可能无法处理大规模的问题，因为这可能导致计算时间和空间的复杂性增加。
蚂蚁群算法摘要：1.蚂蚁群算法简介2.蚂蚁群算法的原理3.蚂蚁群算法的应用领域4.蚂蚁群算法的发展前景正文：蚂蚁群算法是一种模拟自然界蚂蚁觅食行为的算法，它具有较强的全局搜索能力和优秀的全局优化性能。
该算法是由意大利学者Mario Dorigo于1992年首次提出的，被称为蚁群优化算法（Ant Colony Optimization, ACO）。
1.蚂蚁群算法简介蚂蚁群算法是一种基于模拟蚂蚁觅食行为的优化算法。
在自然界中，蚂蚁觅食的过程中会释放一种名为信息素的化学物质，这种物质可以用来标记食物源的位置。
蚂蚁群算法通过模拟这一过程，对问题进行求解。
该算法采用分布式计算的方式，具有计算速度快、搜索效率高等优点。
2.蚂蚁群算法的原理蚂蚁群算法的基本思想是模拟蚂蚁觅食过程中的信息素更新过程。
在算法执行过程中，每个蚂蚁都是一个独立的优化实体，它们根据概率分布选择下一个要访问的节点。
蚂蚁在搜索过程中会不断地更新信息素，信息素的更新规则包括信息素的挥发和蚂蚁在路径上留下的信息素。
通过信息素的更新，蚂蚁群算法可以找到从起点到目标的最短路径。
3.蚂蚁群算法的应用领域蚂蚁群算法在许多领域都有广泛的应用，如信号处理、机器学习、图像处理、工程优化、生物信息学等。
其中，最著名的应用是求解旅行商问题（Travelling Salesman Problem, TSP）。
此外，蚂蚁群算法还在网络路由优化、无线传感器网络定位、负载均衡等领域取得了显著的成果。
4.蚂蚁群算法的发展前景蚂蚁群算法作为一种典型的生物启发式算法，具有较高的研究价值和应用前景。
随着人工智能、大数据等技术的发展，蚂蚁群算法在各个领域的应用将越来越广泛。
同时，研究人员还在不断地对该算法进行改进和优化，以提高其搜索效率和适用范围。
蚁群算法蚁群算法(ant colony optimization, ACO)，又称蚂蚁算法，是一种用来在图中寻找优化路径的机率型算法。
它由Marco Dorigo于1992年在他的博士论文中提出，其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。
蚁群算法是一种模拟进化算法,初步的研究表明该算法具有许多优良的性质.针对PID控制器参数优化设计问题,将蚁群算法设计的结果与遗传算法设计的结果进行了比较,数值仿真结果表明,蚁群算法具有一种新的模拟进化优化方法的有效性和应用价值。
预期的结果：各个蚂蚁在没有事先告诉他们食物在什么地方的前提下开始寻找食物。
当一只找到食物以后，它会向环境释放一种挥发性分泌物pheromone (称为信息素,该物质随着时间的推移会逐渐挥发消失，信息素浓度的大小表征路径的远近)来实现的，吸引其他的蚂蚁过来，这样越来越多的蚂蚁会找到食物。
有些蚂蚁并没有象其它蚂蚁一样总重复同样的路，他们会另辟蹊径，如果另开辟的道路比原来的其他道路更短，那么，渐渐地，更多的蚂蚁被吸引到这条较短的路上来。
最后，经过一段时间运行，可能会出现一条最短的路径被大多数蚂蚁重复着。
编辑本段原理：设想，如果我们要为蚂蚁设计一个人工智能的程序，那么这个程序要多么复杂呢？首先，你要让蚂蚁能够避开障碍物，就必须根据适当的地形给它编进指令让他们能够巧妙的避开障碍物，其次，要让蚂蚁找到食物，就需要让他们遍历空间上的所有点；再次，如果要让蚂蚁找到最短的路径，那么需要计算所有可能的路径并且比较它们的大小，而且更重要的是，你要小心翼翼的编程，因为程序的错误也许会让你前功尽弃。
这是多么不可思议的程序！太复杂了，恐怕没人能够完成这样繁琐冗余的程序。
然而，事实并没有你想得那么复杂，上面这个程序每个蚂蚁的核心程序编码不过100多行！为什么这么简单的程序会让蚂蚁干这样复杂的事情？答案是：简单规则的涌现。
事实上，每只蚂蚁并不是像我们想象的需要知道整个世界的信息，他们其实只关心很小范围内的眼前信息，而且根据这些局部信息利用几条简单的规则进行决策，这样，在蚁群这个集体里，复杂性的行为就会凸现出来。
1. 蚁群算法简介蚁群算法（Ant Clony Optimization，ACO）是一种群智能算法，它是由一群无智能或有轻微智能的个体（Agent）通过相互协作而表现出智能行为，从而为求解复杂问题提供了一个新的可能性。
蚁群算法最早是由意大利学者Colorni A., Dorigo M. 等于1991年提出。
经过20多年的发展，蚁群算法在理论以及应用研究上已经得到巨大的进步。
蚁群算法是一种仿生学算法，是由自然界中蚂蚁觅食的行为而启发的。
在自然界中，蚂蚁觅食过程中，蚁群总能够按照寻找到一条从蚁巢和食物源的最优路径。
图（1）显示了这样一个觅食的过程。
图（1）蚂蚁觅食在图1（a）中，有一群蚂蚁，假如A是蚁巢，E是食物源（反之亦然）。
这群蚂蚁将沿着蚁巢和食物源之间的直线路径行驶。
假如在A和E之间突然出现了一个障碍物（图1（b）），那么，在B点（或D点）的蚂蚁将要做出决策，到底是向左行驶还是向右行驶？由于一开始路上没有前面蚂蚁留下的信息素（pheromone），蚂蚁朝着两个方向行进的概率是相等的。
但是当有蚂蚁走过时，它将会在它行进的路上释放出信息素，并且这种信息素会议一定的速率散发掉。
信息素是蚂蚁之间交流的工具之一。
它后面的蚂蚁通过路上信息素的浓度，做出决策，往左还是往右。
很明显，沿着短边的的路径上信息素将会越来越浓（图1（c）），从而吸引了越来越多的蚂蚁沿着这条路径行驶。
2. TSP问题描述蚁群算法最早用来求解TSP问题，并且表现出了很大的优越性，因为它分布式特性，鲁棒性强并且容易与其它算法结合，但是同时也存在这收敛速度慢，容易陷入局部最优（local optimal）等缺点。
TSP问题（Travel Salesperson Problem，即旅行商问题或者称为中国邮递员问题），是一种，是一种NP-hard问题，此类问题用一般的算法是很大得到最优解的，所以一般需要借助一些启发式算法求解，例如遗传算法（GA），蚁群算法（ACO），微粒群算法（PSO）等等。
TSP问题可以分为两类，一类是对称TSP问题（Symmetric TSP），另一类是非对称问题（Asymmetric TSP）。
所有的TSP问题都可以用一个图（Graph）来描述：令V={c1, c2, …, c i, …, c n}，i = 1,2, …, n，是所有城市的集合. c i表示第i个城市， n为城市的数目；E={(r, s): r,s∈V}是所有城市之间连接的集合；C = {c rs: r,s∈V}是所有城市之间连接的成本度量（一般为城市之间的距离）；如果c rs = c sr, 那么该TSP问题为对称的，否则为非对称的。
一个TSP问题可以表达为：求解遍历图G = (V, E, C)，所有的节点一次并且回到起始节点，使得连接这些节点的路径成本最低。
3. 蚁群算法原理假如蚁群中所有蚂蚁的数量为m，所有城市之间的信息素用矩阵pheromone表示，最短路径为bestLength，最佳路径为bestTour。
每只蚂蚁都有自己的内存，内存中用一个禁忌表（Tabu）来存储该蚂蚁已经访问过的城市，表示其在以后的搜索中将不能访问这些城市；还有用另外一个允许访问的城市表（Allowed）来存储它还可以访问的城市；另外还用一个矩阵（Delta）来存储它在一个循环（或者迭代）中给所经过的路径释放的信息素；还有另外一些数据，例如一些控制参数（，，，Q），该蚂蚁行走玩全程的总成本或距离（tourLength），等等。
假定算法总共运行MAX_GEN次，运行时间为t。
蚁群算法计算过程如下：（1）初始化设t=0，初始化bestLength为一个非常大的数（正无穷），bestTour为空。
初始化所有的蚂蚁的Delt矩阵所有元素初始化为0，Tabu表清空，Allowed表中加入所有的城市节点。
随机选择它们的起始位置（也可以人工指定）。
在Tabu中加入起始节点，Allowed中去掉该起始节点。
（2）为每只蚂蚁选择下一个节点。
为每只蚂蚁选择下一个节点，该节点只能从Allowed中以某种概率（公式1）搜索到，每搜到一个，就将该节点加入到Tabu中，并且从Allowed中删除该节点。
该过程重复n-1次，直到所有的城市都遍历过一次。
遍历完所有节点后，将起始节点加入到Tabu中。
此时Tabu表元素数量为n+1（n为城市数量），Allowed元素数量为0。
接下来按照（公式2）计算每个蚂蚁的Delta矩阵值。
最后计算最佳路径，比较每个蚂蚁的路径成本，然后和bestLength比较，若它的路径成本比bestLength小，则将该值赋予bestLength，并且将其Tabu赋予BestTour。
（公式1）（公式2）其中表示选择城市j的概率，k表示第k个蚂蚁，表示城市i，j在第t时刻的信息素浓度，表示从城市i到城市j的可见度，，表示城市i，j之间的成本（或距离）。
由此可见越小，越大，也就是从城市i到j的可见性就越大。
表示蚂蚁k在城市i与j之间留下的信息素。
表示蚂蚁k经过一个循环（或迭代）锁经过路径的总成本（或距离），即tourLength. ，，Q均为控制参数。
（3）更新信息素矩阵令t = t + n，按照（公式3）更新信息素矩阵phermone。
（公式3）为t+n时刻城市i与j之间的信息素浓度。
为控制参数，为城市i与j之间信息素经过一个迭代后的增量。
并且有（公式4）其中由公式计算得到。
（4）检查终止条件如果达到最大代数MAX_GEN，算法终止，转到第（5）步；否则，重新初始化所有的蚂蚁的Delt矩阵所有元素初始化为0，Tabu表清空，Allowed表中加入所有的城市节点。
随机选择它们的起始位置（也可以人工指定）。
在Tabu中加入起始节点，Allowed中去掉该起始节点，重复执行（2），（3）,(4)步。
（5）输出最优值// 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] ,BETA); //该城市和当前城市间的信息素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//会出现经过上述操作，没有城市被选择出来//出现这种情况，就把第一个没去过的城市作为返回结果//题外话：刚开始看的时候，下面这段代码困惑了我很长时间，想不通为何要有这段代码，后来才搞清楚。
