蚁群算法最短路径通用Matlab程序(附图)

PythonMatlab实现蚂蚁群算法求解最短路径问题的⽰例⽬录1知识点1.1 蚁群算法步骤1.2 蚁群算法程序2蚂蚁算法求解最短路径问题——Python实现2.1源码实现2.2 ACA_TSP实现3 蚂蚁算法求解最短路径问题——Matlab实现3.1流程图3.2代码实现3.3结果1 知识点详细知识点见：我们这⼀节知识点只讲蚁群算法求解最短路径步骤及流程。

1.1 蚁群算法步骤设蚂蚁的数量为m，地点的数量为n，地点i与地点j之间相距Dij，t时刻地点i与地点j连接的路径上的信息素浓度为Sij,初始时刻每个地点间路径上的信息素浓度相等。

蚂蚁k根据各个地点间连接路径上的信息素决定下⼀个⽬标地点，Pijk表⽰t时刻蚂蚁k从地点i转移的概率，概率计算公式如下：上式中，为启发函数，，表⽰蚂蚁从地点i转移到地点j的期望程度；为蚂蚁k即将访问地点的集合，开始时中有n-1个元素（除出发地点），随时间的推移，蚂蚁每到达下⼀个地点，中的元素便减少⼀个，直⾄空集，即表⽰所有地点均访问完毕；a为信息素重要程度因⼦，值越⼤，表明信息素的浓度在转移中起到的作⽤越⼤，也就是说蚂蚁选择距离近的下⼀个地点的概率更⼤，β为启发函数重要程度因⼦。

蚂蚁在释放信息素的同时，每个地点间连接路径上的信息素逐渐消失，⽤参数表⽰信息素的挥发程度。

因此，当所有蚂蚁完成⼀次循环后，每个地点间连接路径上的信息素浓度需更新，也就是有蚂蚁路过并且留下信息素，有公式表⽰为：其中，表⽰第k只蚂蚁在地点i与j连接路径上释放的信息素浓度；表⽰所有蚂蚁在地点i与j连接路径上释放的信息素浓度之和；Q为常数，表⽰蚂蚁循环⼀次所释放的信息素总量；Lk表⽰第k只蚂蚁经过路径的长度，总的来说，蚂蚁经过的路径越短，释放的信息素浓度越⾼，最终选出最短路径。

1.2 蚁群算法程序(1)参数初始化在寻最短路钱，需对程序各个参数进⾏初始化，蚁群规模m、信息素重要程度因⼦α、启发函数重要程度因⼦β、信息素会发因⼦、最⼤迭代次数ddcs_max，初始迭代值为ddcs=1。

蚁群算法matlab精讲及仿真4.1基本蚁群算法4.1.1基本蚁群算法的原理蚁群算法是上世纪90年代意大利学者M.Dorigo,v.Maneizz。

等人提出来的,在越来越多的领域里得到广泛应用。

蚁群算法，是一种模拟生物活动的智能算法，蚁群算法的运作机理来源于现实世界中蚂蚁的真实行为，该算法是由 Marco Dorigo 首先提出并进行相关研究的，蚂蚁这种小生物，个体能力非常有限，但实际的活动中却可以搬动自己大几十倍的物体，其有序的合作能力可以与人类的集体完成浩大的工程非常相似，它们之前可以进行信息的交流，各自负责自己的任务，整个运作过程统一有序，在一只蚂蚁找食物的过程中，在自己走过的足迹上洒下某种物质，以传达信息给伙伴，吸引同伴向自己走过的路径上靠拢，当有一只蚂蚁找到食物后，它还可以沿着自己走过的路径返回，这样一来找到食物的蚂蚁走过的路径上信息传递物质的量就比较大，更多的蚂蚁就可能以更大的机率来选择这条路径，越来越多的蚂蚁都集中在这条路径上，蚂蚁就会成群结队在蚁窝与食物间的路径上工作。

当然，信息传递物质会随着时间的推移而消失掉一部分，留下一部分，其含量是处于动态变化之中，起初，在没有蚂蚁找到食物的时候，其实所有从蚁窝出发的蚂蚁是保持一种随机的运动状态而进行食物搜索的，因此，这时，各蚂蚁间信息传递物质的参考其实是没有价值的，当有一只蚂蚁找到食物后，该蚂蚁一般就会向着出发地返回，这样，该蚂蚁来回一趟在自己的路径上留下的信息传递物质就相对较多，蚂蚁向着信息传递物质比较高的路径上运动，更多的蚂蚁就会选择找到食物的路径，而蚂蚁有时不一定向着信息传递物质量高的路径走，可能搜索其它的路径。

这样如果搜索到更短的路径后，蚂蚁又会往更短的路径上靠拢，最终多数蚂蚁在最短路径上工作。

【基于蚁群算法和遗传算法的机器人路径规划研究】该算法的特点：(1)自我组织能力，蚂蚁不需要知道整体环境信息，只需要得到自己周围的信息，并且通过信息传递物质来作用于周围的环境，根据其他蚂蚁的信息素来判断自己的路径。

蚁群算法与模拟退火算法对旅游路线问题的探究（附matlab程序）蚁群算法与模拟退火算法对旅游路线问题的探究张煊张恒伟徐晓辉摘要：本文针对旅游中国34个城市的路线最优化问题，收集各城市经纬度坐标和实际城市间火车票与飞机票，在此大量数据的基础之上，采用蚁群算法和模拟退火算法进行启发式搜索，就实际问题给出了合理最优的旅行路线和订票方案。

按照问题要求，首先建立了城市旅行网络，同时对网络图赋权，对数据进行了收集和简单的处理，得到了经纬度坐标、火车票矩阵、飞机票矩阵及其对应的时间矩阵。

对于问题（1），我们根据各城市经纬度坐标，利用经纬度知识和球体的几何知识，计算出各城市之间的距离，得到各个城市之间的距离矩阵，分别采用蚁群算法与模拟退火算法搜索，将结果比较得到最短旅行路线为：哈尔滨—长春—沈阳—天津—北京—呼和浩特—太原—石家庄—济南—郑州—西安—银川—兰州—西宁—乌鲁木齐—拉萨—昆明—成都—重庆—贵阳—南宁—海口—广州—澳门—香港—台北—福州—南昌—长沙—武汉—合肥—南京—杭州—上海—哈尔滨，旅行路线总长为1.6013万千米。

在问题（2）的求解中，首先用城市旅行网络的车费价格代替城市之间距离，重新赋权，在模型Ⅰ的基础上，利用最小费用矩阵，采用蚁群算法和模拟退火算法搜索，比较计算结果得到最经济的订票方案为：哈尔滨—1489—长春—1416—天津—1416—济南—1462—南京—1462—上海—1374—杭州—2002—福州—1216—南昌—K162—合肥—D3024—武汉—MU517—台北—CZ6997—澳门—MU2790—西宁—1282—拉萨—K918—兰州—1043—乌鲁木齐—1043—西安—2612—郑州—T201—海口—T201—广州—T99—香港—T98—长沙—2514—南宁—2058—昆明—1236—贵阳—1248—重庆—1271—成都—1718—银川—2636—呼和浩特—2464—太原—2610—石家庄—4410—北京—1138—沈阳—1122—哈尔滨，费用7212元。

蚁群算法matlab代码讲解蚁群算法（Ant Colony Algorithm）是模拟蚁群觅食行为而提出的一种优化算法。

它以蚁群觅食的方式来解决优化问题，比如旅行商问题、图着色问题等。

该算法模拟了蚂蚁在寻找食物时的行为，通过信息素的正反馈和启发式搜索来实现问题的最优解。

在蚁群算法中，首先需要初始化一组蚂蚁和问题的解空间。

每只蚂蚁沿着路径移动，通过信息素和启发式规则来选择下一步的移动方向。

当蚂蚁到达目标位置后，会根据路径的长度来更新信息素。

下面是一个用MATLAB实现蚁群算法的示例代码：```matlab% 参数设置num_ants = 50; % 蚂蚁数量num_iterations = 100; % 迭代次数alpha = 1; % 信息素重要程度因子beta = 5; % 启发式因子rho = 0.1; % 信息素蒸发率Q = 1; % 信息素增加强度因子pheromone = ones(num_cities, num_cities); % 初始化信息素矩阵% 初始化蚂蚁位置和路径ants = zeros(num_ants, num_cities);for i = 1:num_antsants(i, 1) = randi([1, num_cities]);end% 迭代计算for iter = 1:num_iterations% 更新每只蚂蚁的路径for i = 1:num_antsfor j = 2:num_cities% 根据信息素和启发式规则选择下一步移动方向next_city = choose_next_city(pheromone, ants(i, j-1), beta);ants(i, j) = next_city;endend% 计算每只蚂蚁的路径长度path_lengths = zeros(num_ants, 1);for i = 1:num_antspath_lengths(i) = calculate_path_length(ants(i, :), distances);end% 更新信息素矩阵pheromone = (1 - rho) * pheromone;for i = 1:num_antsfor j = 2:num_citiespheromone(ants(i, j-1), ants(i, j)) = pheromone(ants(i, j-1), ants(i, j)) + Q / path_lengths(i); endendend```上述代码中的参数可以根据具体问题进行调整。

蚁群算法（ACA）及其Matlab实现1基本原理：本质上也是⼀种概率算法，通过⼤概率收敛到最佳值，和其他的智能算法很相似。

蚁群分泌的信息素存在正反馈，使得较佳的解具有⼤概率被选到，当全局都选⽤较佳的解，变可以得到整体的最优解。

2⼏个关键点：1）概率选择：受信息素浓度和启发函数影响，启发函数为距离的倒数2）信息素挥发考虑到信息素随时间的挥发，加⼊挥发因⼦3程序设计步骤：1初始化各个参数：包括各点的距离，信息素的初始浓度，蚂蚁数量，信息素挥发因⼦，信息素和启发函数的重要度因⼦，启发函数，最⼤迭代次数，路径记录表等等2迭代：对每个蚂蚁随机制定初始值，再根据概率选择，选择出每只蚂蚁的路径，确定每只蚂蚁的路径总长度，以及蚁群的最佳路径长度和平均长度，并对信息素进⾏更新。

3展⽰：展⽰出最佳路径，以及最佳路径对迭代的变化图4Matlab代码clc,clear %清空环境中的变量load data.txt %读⼊城市的坐标t0 = clock; %程序计时开始%%%%%%%%%%%%%%%%%%%%%初始化%%%%%%%%%%%%%%%%%city=data;n = size(city,1); %城市距离初始化D = zeros(n,n);for i = 1:nfor j = 1:nif i ~= jD(i,j) = sqrt(sum((city(i,:) - city(j,:)).^2));elseD(i,j) = 0; %设定的对⾓矩阵修正值endendendm=30; %蚂蚁数量alpha = 1; % 信息素重要程度因⼦beta = 5; % 启发函数重要程度因⼦v = 0.1; % 信息素挥发因⼦Q = 0.5; % 信息因⼦常系数H= 1./D; % 启发函数T= ones(n,n); % 信息素矩阵Table = zeros(m,n); % 路径记录表iter = 1; % 迭代次数初值iter_max = 50; % 最⼤迭代次数best_route = zeros(iter_max,n); % 各代最佳路径best_length = zeros(iter_max,1); % 各代最佳路径的长度%%while iter<=iter_max% 随机产⽣每只蚂蚁的起点城市start = zeros(m,1);for i = 1:mtemp = randperm(n);start(i) = temp(1);endTable(:,1) = start;city_index=1:n;for i = 1:m% 逐个城市路径选择for j = 2:ntabu = Table(i,1:(j - 1)); % 已访问的城市集合allow =city_index( ~ismember(city_index,tabu)); % 筛选出未访问的城市集合P = zeros(1,length(allow));% 计算相连城市的转移概率for k = 1:length(allow)P(k) = T(tabu(end),allow(k))^alpha * H(tabu(end),allow(k))^beta;endP = P/sum(P);% 轮盘赌法选择下⼀个访问城市Pc = cumsum(P); %参加说明2(程序底部)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,:) Table(i,1)];for j = 1:nLength(i) = Length(i) + D(Route(j),Route(j + 1));endend%对最优路线和距离更新if iter == 1[min_length,min_index] = min(Length);best_length(iter) = min_length;best_route(iter,:) = Table(min_index,:);else[min_length,min_index] = min(Length);if min_length<best_length(iter-1)best_length(iter)=min_length;best_route(iter,:)=Table(min_index,:);elsebest_length(iter)=best_length(iter-1);best_route(iter,:)=best_route(iter-1,:);endend% 更新信息素Delta_T= zeros(n,n);% 逐个蚂蚁计算for i = 1:m% 逐个城市计算Route = [Table(i,:) Table(i,1)];for j = 1:nDelta_T(Route(j),Route(j+1)) = Delta_T(Route(j),Route(j+1)) +D(Route(j),Route(j+1))* Q/Length(i); endendT= (1-v) * T + Delta_T;% 迭代次数加1，并清空路径记录表iter = iter + 1;Table = zeros(m,n);end%--------------------------------------------------------------------------%% 结果显⽰shortest_route=best_route(end,:); %选出最短的路径中的点short_length=best_length(end);Time_Cost=etime(clock,t0);disp(['最短距离:' num2str(short_length)]);disp(['最短路径:' num2str([shortest_route shortest_route(1)])]);disp(['程序执⾏时间:' num2str(Time_Cost) '秒']);%--------------------------------------------------------------------------%% 绘图figure(1)%采⽤连线图画起来plot([city(shortest_route,1);city(shortest_route(1),1)], [city(shortest_route,2);city(shortest_route(1),2)],'o-');for i = 1:size(city,1)%对每个城市进⾏标号text(city(i,1),city(i,2),[' ' num2str(i)]);endxlabel('城市位置横坐标')ylabel('城市位置纵坐标')title(['蚁群算法最优化路径(最短距离）:' num2str(short_length) ''])figure(2)%画出收敛曲线plot(1:iter_max,best_length,'b')xlabel('迭代次数')ylabel('距离')title('迭代收敛曲线')　程序说明：采⽤蚁群算法求取TSP问题，共有34个城市，从txt⽂件加载数据：运⾏结果：。

基于蚁群算法的机器人路径规划MＡＴLAＢ源代码————————————————————————————————作者: ————————————————————————————————日期:基于蚁群算法的机器人路径规划MATＬＡB源代码基本思路是，使用离散化网格对带有障碍物的地图环境建模，将地图环境转化为邻接矩阵,最后使用蚁群算法寻找最短路径。

funｃtｉｏn [RＯＵＴES,PL,Ｔａu]＝ACASＰS(Ｇ,Ｔaｕ,Ｋ,Ｍ,S,E，Aｌpha,Bｅta，Rho,Ｑ）%％-------------------－-－-－------------－-------－－－--－-－--－------－-% ＡCAＳＰ.m%基于蚁群算法的机器人路径规划％GrｅenＳim团队——专业级算法设计&代写程序% 欢迎访问GrｅｅnSｉm团队主页→%% -－－----－-－－----－---－------－--－-－---－-－-----------－-----－－-－--－－％输入参数列表% Ｇ地形图为01矩阵,如果为1表示障碍物％Ｔａu 初始信息素矩阵(认为前面的觅食活动中有残留的信息素）％K 迭代次数（指蚂蚁出动多少波)% M 蚂蚁个数（每一波蚂蚁有多少个)% Ｓ起始点（最短路径的起始点)% Ｅ终止点(最短路径的目的点)％Alphａ表征信息素重要程度的参数% Beta 表征启发式因子重要程度的参数%Rｈo 信息素蒸发系数% Q 信息素增加强度系数％％输出参数列表% RＯUＴＥＳ每一代的每一只蚂蚁的爬行路线%PL 每一代的每一只蚂蚁的爬行路线长度％Tau 输出动态修正过的信息素%% ----－-－---－-－－－－－－-－变量初始化-－--－－-------－-－-－－---－----－-－----%ｌoaｄD=Ｇ２D(Ｇ);Ｎ=sizｅ（D,1);%Ｎ表示问题的规模(象素个数)MM=sｉzｅ(G,1);a=１;%小方格象素的边长Ｅx＝a*(mod(Ｅ，MM)－０.5);%终止点横坐标if Ｅx==-0.5Ｅx=MM-0．5;eｎdEy=a＊（MM+0.5－ceil(E/MM));％终止点纵坐标Eta=zeros（１,N);%启发式信息，取为至目标点的直线距离的倒数%下面构造启发式信息矩阵fｏr i=1:Nｉx=a*(mod(ｉ，MM）-0．５)；if ix==-0．5ix=MM-0.5;ｅnｄiy＝a*（MＭ+0．5-ceil(i/MM)）;iｆi~＝EEｔａ(1，ｉ)=１/((iｘ-Ex)^2+(iｙ-Ey）＾２)^０.5;ｅlｓeEta(1，i)＝1０0;endeｎdROＵTＥS＝cell（K,Ｍ);%用细胞结构存储每一代的每一只蚂蚁的爬行路线ＰL=zeros(Ｋ,Ｍ);%用矩阵存储每一代的每一只蚂蚁的爬行路线长度%％－--------－-启动K轮蚂蚁觅食活动，每轮派出M只蚂蚁------－－--－--------- ｆorｋ=１:Ｋ%diｓp(k);fｏｒm=1:M％% 第一步：状态初始化W=Ｓ;％当前节点初始化为起始点Path=S;％爬行路线初始化PLｋm=０;%爬行路线长度初始化ＴAＢUkm(S)=0;％已经在初始点了,因此要排除DD＝D；%邻接矩阵初始化%％第二步:下一步可以前往的节点ＤW=DD（W,:);DW1＝finｄ(DW<ｉnf）;ｆoｒj=1：length(DW１）ｉf TAＢUｋm(DW1(ｊ))==０enｄendLJD=ｆind(ＤW<ｉｎf）;%可选节点集Leｎ_ＬＪD=ｌeｎgｔｈ(LＪD);%可选节点的个数%% 觅食停止条件：蚂蚁未遇到食物或者陷入死胡同while W~=E&&Ｌeｎ_LJD>=1%%第三步：转轮赌法选择下一步怎么走PP=zｅros（1,Len_LJD);for i＝1:Lｅn_LJDendPＰ=PP/(ｓum(PＰ）);％建立概率分布Pcｕm=cumｓｕm（PP）;Sｅlｅcｔ＝find（Ｐcum＞=rａnd);to_vｉsit=ＬＪＤ(Seleｃｔ(1));%下一步将要前往的节点%% 第四步：状态更新和记录Path=[Path,to_visit］；%路径增加PLkm=PＬｋm+DD（Ｗ,tｏ_vｉsit）；%路径长度增加Ｗ=to＿viｓｉｔ;%蚂蚁移到下一个节点for kk＝1:Nif ＴABUkm(kｋ）==０DD（W,ｋｋ）＝inｆ;DD(kk,W)=inf;eｎｄenｄＴAＢUkm（Ｗ）＝0;％已访问过的节点从禁忌表中删除DＷ=ＤＤ(Ｗ,：);LJD=find（DW<inf）;%可选节点集Ｌen_LJD＝lenｇth(LＪＤ);%可选节点的个数end%% 第五步：记下每一代每一只蚂蚁的觅食路线和路线长度ROUＴES｛k,m}=Ｐaｔh；if Ｐaｔh(enｄ)==EPＬ(k,m)＝ＰLkm；elsePL（k，ｍ)=ｉnf;eｎdenｄ%% 第六步:更新信息素Ｄelｔa_Ｔau=zerｏs（Ｎ，N);%更新量初始化for m=1:MiｆPＬ(ｋ，m)<iｎfROＵT=ＲＯUＴES{k,m};TＳ=lｅngtｈ(ROＵT)-1;%跳数ＰL_ｋｍ=ＰL(k,m);for s=1:TＳx=ROUＴ(ｓ);y=ＲOUT(s+1）；Dｅｌtａ_Tａu(x,y）=Dｅlta_Tau（x，y）+Q/ＰL_km;Ｄｅlta＿Tau(y,ｘ)＝Ｄeｌta_Ｔau(ｙ,x)＋Ｑ／PL＿km；endeｎdｅndTau=(1-Rho).*Taｕ+Delｔa＿Tａu;％信息素挥发一部分，新增加一部分ｅｎd%% －---－－-------－－----－---－-－－绘图--－--－－－----－-----－-------－---－－ｐlotif=0;%是否绘图的控制参数if plotif＝=１%绘收敛曲线meａnPＬ=zeros(1，K）;mｉnPL=zerｏｓ(1,K);for i＝1:KPLK=PL（ｉ,:）;Noｎzｅro＝ｆinｄ(ＰLＫ<inｆ)；PLKＰLＫ=PLK(Nonzeｒo）;meａｎPL(i）＝ｍean(PＬKPLK);miｎＰL(i)=ｍin(PＬKPLK)；eｎdfｉｇure（1)pｌｏt(mｉｎPL);ｈold onｐｌot(meaｎPＬ）;grid onｔｉtle('收敛曲线(平均路径长度和最小路径长度）');xｌａｂel('迭代次数');ylaｂel（'路径长度＇）；%绘爬行图fｉｇuｒe(2)axis([0,MM,０,ＭM])forｉ=1:ＭMfor j=1：ＭMｉｆG(i，j）==1x1=j-1；y1=MＭ－ｉ;x2=j;ｙ２=MM-ｉ；ｘ3=j;y3=MM-i+1;ｘ4=j-1;ｙ4＝MＭ-i+１;fｉlｌ([x1,x２,ｘ3,x4]，[y1,y2，y3,y4],［０.2，０．2，０.2］）;hoｌd ｏnｅlsex１=j－1;y1=ＭM－i;x2＝j；y２=ＭM－i;ｘ３=ｊ；y3=MM－i+1;x4=j－1;y4=MM－i＋1;fill（[x１,x2,x3,ｘ4],[ｙ1,y２,y3,ｙ４],[1,1,1])；hold oｎendｅndeｎdhｏld ｏnROUＴ=ＲOUＴＥＳ｛Ｋ,M};Ｒx＝ROUT;Ｒy=ROUT;foｒii＝1：LENRＯＵTRｘ(iｉ)=a*(mod（ＲOUT(ii)，MM）-０.５）;if Rx(ii)＝=－0.5Rx(ii）=ＭM-0.5；enｄＲy(ｉi）＝ａ*（MM+0.5-ｃeiｌ(ROUT(ｉi）/MM））;enｄｐlｏt(Rｘ,Ｒy）endpｌotｉf2=0;%绘各代蚂蚁爬行图if pｌotif２=＝1ｆigｕre（3）axis([0,MM,0,MM]）for i=1:MＭｆｏr j=1:ＭMｉf G(ｉ，j)==１ｘ1=ｊ-１;ｙ１＝MM-i;x2＝j；ｙ2=MM-i;x4=ｊ-1;y4=MM-i+１;fill([ｘ1,x２，x3，x4]，[y1，y２,y３,y4]，[0.2,0.２,０.2])；ｈold ｏneｌｓex1=ｊ-1;y1=MＭ－ｉ；x2＝ｊ；y2=MM－i;x3=j;ｙ３=MM-i+1;x４=j-１;ｙ4=MＭ-i+１;fill([ｘ1，x2,ｘ3,ｘ4],［y1,y２,ｙ3，y４],［1，１，1]);hｏld onｅndeｎｄeｎｄfｏｒｋ=1：ＫPLK=ＰL(ｋ,：）;mｉnＰLK=mｉｎ(PＬK);ｐos=fiｎｄ(PLK==minPLK）；m=ｐos（1);ＲOUT=ROＵTＥS{k,ｍ};LＥNROUＴ＝lｅngｔh（ROUＴ);Rx=ROUＴ;Ｒy＝RＯUT;ｆor iｉ=1:ＬＥNRＯＵTRx（iｉ)=a*(moｄ(RＯUT（ii)，ＭＭ)-0．5);if Rx(ｉi)==-0．5Rx(ii）=MM-0.5;enｄRy(ii）=ａ*(MM+0.5-ceｉl(RＯUT(ｉｉ)／MＭ)）;enｄplot（Rｘ,Rｙ)hold oｎenｄend源代码运行结果展示。

蚁群算法介绍：(1)寻找最短路径的蚁群算法来源于蚂蚁寻食的行为。

蚁群寻找食物时会派出一些蚂蚁分头在四周游荡, 如果一只蚂蚁找到食物, 它就返回巢中通知同伴并沿途留下“ 信息素”(外激素pheromone)作为蚁群前往食物所在地的标记。

信息素会逐渐挥发,如果两只蚂蚁同时找到同一食物, 又采取不同路线回到巢中, 那么比较绕弯的一条路上信息素的气味会比较淡, 蚁群将倾向于沿另一条更近的路线前往食物所在地。

蚁群算法设计虚拟的“蚂蚁”, 让它们摸索不同路线, 并留下会随时间逐渐消失的虚拟“信息素”, 根 据“信息素较浓的路线更近”的原则, 即可选择出最佳路线.(2) 为了模拟实际蚂蚁的行为, 首先引进如下记号: 设m 是蚁群中蚂蚁的数, ij d (i,j=1,2,...,n)表示城市i 和城市j 之间的距离, i b t 表示t 时刻位于城市i 的蚂蚁的个数,则有 1ni i mb tij t表示t 时刻在城市,i j 连线上残留的信息素。

初始时刻，各条路径上的信息素相等，设0ij c c 为常数。

蚂蚁1,2,,k k m 在运动过程中，根据各条路径上的信息素决定转移方向。

k ij P t 表示在t 时刻蚂蚁k 由城市i 转移到城市j 的概率：,0,kij ij kik ikij kktabu kt t t P j tabu j tabu （1） 其中：ij n 为先验知识或称为能见度，在TSP 问题中为城市i 转移到城市j 的启发信息，一般地取1ij d ij n ，为在路径上残留信息的重要程度；为启发信息的重要程度；与实际蚁群不同，人工蚁群系统具有记忆能力，1,2,,k tabu k m 用以记录蚂蚁K 当前所走过的城市，称为禁忌表（下一步不充许选择的城市），集合k tabu 随着进化过程进行动态调整。

经过n 个时刻，所有蚂蚁完成了一次周游，此时应清空禁忌表，将当前蚂蚁所在的城市置入k tabu 中准备下一次周游，这时计算每一只蚂蚁走过的路程k L ，并保存最短路径min min min ,1,,k L L L k m 。

139§19. 利用Matlab 编程计算最短路径及中位点选址1、最短路问题两个指定顶点之间的最短路径。

例如，给出了一个连接若干个城镇的铁路网络，在这个网络的两个指定城镇间，找一条最短铁路线。

以各城镇为图G 的顶点，两城镇间的直通铁路为图G 相应两顶点间的边，得图G 。

对G 的每一边e ，赋以一个实数)(e w —直通铁路的长度，称为e 的权，得到赋权图G 。

G 的子图的权是指子图的各边的权和。

问题就是求赋权图G 中指定的两个顶点00,v u 间的具最小权的轨。

这条轨叫做00,v u 间的最短路，它的权叫做00,v u 间的距离，亦记作),(00v u d 。

求最短路已有成熟的算法：迪克斯特拉（Dijkstra ）算法，其基本思想是按距0u 从近到远为顺序，依次求得0u 到G 的各顶点的最短路和距离，直至0v （或直至G 的所有顶点），算法结束。

为避免重复并保留每一步的计算信息，采用了标号算法。

下面是该算法。

(i) 令0)(0=u l ，对0u v ≠，令∞=)(v l ，}{00u S =，0=i 。

(ii) 对每个i S v ∈（i i S V S \=），用)}()(),({min uv w u l v l iS u +∈代替)(v l 。

计算)}({min v l iS v ∈，把达到这个最小值的一个顶点记为1+i u ，令140}{11++=i i i u S S 。

(iii). 若1||-=V i ，停止；若1||-<V i ，用1+i 代替i ，转(ii)。

算法结束时，从0u 到各顶点v 的距离由v 的最后一次的标号)(v l 给出。

在v 进入i S 之前的标号)(v l 叫T 标号，v 进入i S 时的标号)(v l 叫P 标号。

算法就是不断修改各项点的T 标号，直至获得P 标号。

若在算法运行过程中，将每一顶点获得P 标号所由来的边在图上标明，则算法结束时，0u 至各项点的最短路也在图上标示出来了。

if i~=EEta(1,i)=1/((ix-Ex)^2+(iy-Ey)^2)^0.5;elseEta(1,i)=100;endendROUTES=cell(K,M);%用细胞结构存储每一代的每一只蚂蚁的爬行路线PL=zeros(K,M);%用矩阵存储每一代的每一只蚂蚁的爬行路线长度%% -----------启动K轮蚂蚁觅食活动，每轮派出M只蚂蚁-------------------- for k=1:Kdisp(k);for m=1:M%% 第一步：状态初始化W=S;%当前节点初始化为起始点Path=S;%爬行路线初始化PLkm=0;%爬行路线长度初始化TABUkm=ones(1,N);%禁忌表初始化TABUkm(S)=0;%已经在初始点了，因此要排除DD=D;%邻接矩阵初始化%% 第二步：下一步可以前往的节点DW=DD(W,:);DW1=find(DWfor j=1:length(DW1)if TABUkm(DW1(j))==0DW(j)=inf;endendLJD=find(DWLen_LJD=length(LJD);%可选节点的个数%% 觅食停止条件：蚂蚁未遇到食物或者陷入死胡同while W~=E&&Len_LJD>=1%% 第三步：转轮赌法选择下一步怎么走PP=zeros(1,Len_LJD);for i=1:Len_LJDPP(i)=(Tau(W,LJD(i))^Alpha)*(Eta(LJD(i))^Beta);endPP=PP/(sum(PP));%建立概率分布Pcum=cumsum(PP);Select=find(Pcum>=rand);%% 第四步：状态更新和记录Path=[Path,to_visit];%路径增加PLkm=PLkm+DD(W,to_visit);%路径长度增加W=to_visit;%蚂蚁移到下一个节点for kk=1:Nif TABUkm(kk)==0DD(W,kk)=inf;DD(kk,W)=inf;endendTABUkm(W)=0;%已访问过的节点从禁忌表中删除for j=1:length(DW1)if TABUkm(DW1(j))==0DW(j)=inf;endendLJD=find(DWLen_LJD=length(LJD);%可选节点的个数end%% 第五步：记下每一代每一只蚂蚁的觅食路线和路线长度ROUTES{k,m}=Path;if Path(end)==EPL(k,m)=PLkm;elsePL(k,m)=inf;endend%% 第六步：更新信息素Delta_Tau=zeros(N,N);%更新量初始化for m=1:Mif PL(k,m) ROUT=ROUTES{k,m};TS=length(ROUT)-1;%跳数PL_km=PL(k,m);for s=1:TSx=ROUT(s);Delta_Tau(x,y)=Delta_Tau(x,y)+Q/PL_km;Delta_Tau(y,x)=Delta_Tau(y,x)+Q/PL_km;endendendTau=(1-Rho).*Tau+Delta_Tau;%信息素挥发一部分，新增加一部分end%% ---------------------------绘图-------------------------------- plotif=1;%是否绘图的控制参数if plotif==1%绘收敛曲线meanPL=zeros(1,K);minPL=zeros(1,K);for i=1:KPLK=PL(i,:);Nonzero=find(PLKPLKPLK=PLK(Nonzero);meanPL(i)=mean(PLKPLK);minPL(i)=min(PLKPLK);endfigure(1)plot(minPL);hold onplot(meanPL);grid ontitle('收敛曲线（平均路径长度和最小路径长度）');xlabel('迭代次数');ylabel('路径长度');%绘爬行图figure(2)axis([0,MM,0,MM])for i=1:MMfor j=1:MMif G(i,j)==1x1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[0.2,0.2,0.2]); hold onelsex1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[1,1,1]);hold onendendendhold onROUT=ROUTES{K,M};LENROUT=length(ROUT);Rx=ROUT;Ry=ROUT;for ii=1:LENROUTRx(ii)=a*(mod(ROUT(ii),MM)-0.5);if Rx(ii)==-0.5Rx(ii)=MM-0.5;endRy(ii)=a*(MM+0.5-ceil(ROUT(ii)/MM));endplot(Rx,Ry)endplotif2=1;%绘各代蚂蚁爬行图if plotif2==1figure(3)axis([0,MM,0,MM])for i=1:MMfor j=1:MMif G(i,j)==1x1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[0.2,0.2,0.2]); hold onelsex1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[1,1,1]);hold onendendendfor k=1:KPLK=PL(k,:);minPLK=min(PLK);pos=find(PLK==minPLK);m=pos(1);ROUT=ROUTES{k,m};LENROUT=length(ROUT);Rx=ROUT;Ry=ROUT;for ii=1:LENROUTRx(ii)=a*(mod(ROUT(ii),MM)-0.5);if Rx(ii)==-0.5Rx(ii)=MM-0.5;endRy(ii)=a*(MM+0.5-ceil(ROUT(ii)/MM));将上述算法应用于机器人路径规划，优化效果如下图所示。

基于MATLAB的蚁群算法实验研究程序的应用%蚁周模型，解决TSP问题function AS()%clc%初始化format short;n=6; %n 城市数目m=30; %m 蚂蚁数量Nmax=100;%最大循环次数%d（i，j）城市i，j之间的距离，d is a n*n matrixd=[inf,1,inf,inf,8,inf;1,inf,8,inf,4,5;inf,8,inf,3,6,7;inf,inf,3,inf,inf,10;8,4,6, inf,inf,9;inf,5,7,10,9,inf];y=zeros(n,n);%y(i,j)=1/d(i,j) 在TSP问题中，启发信息for i=1:nfor j=1:ny(i,j)=1/d(i,j);endende=1;%信息启发因子f=1;%期望启发因子Q=20;%S=ones(n,n);%（i，j）路段初始化起始信息素for i=1:nfor j=1:nif d(i,j)==infS(i,i)=0;endendendS1=zeros(n,n);%（i，j）路段信息素增量s=zeros(n,n,m);%s（i，j,k）蚂蚁k在路径i，j上残留的信息素notallowed=ones(m,n);%禁忌表,0表示已经访问过a=zeros(m,n);%蚂蚁循环一次的路径for k=1:ma(k,1)=1+round(rand*(n-1));%将蚂蚁随机放到n个城市上endfor k=1:m % 将初始城市放入禁忌表中notallowed(k,a(k,1))=0;endfor N=1:Nmax %N 循环次数t=2;L=zeros(1,m);while t<=n %重复直至禁忌表满为止for k=1:m%计算蚂蚁k转移的概率i=a(k,t-1);p=zeros(1,n);%p（j）蚂蚁k选择路径i，j的概率for j=1:nif notallowed(k,j)~=0u=(S(i,j)^e)*(y(i,j)^f);v=0;for w=1:nv=v+(S(i,w)^e)*(y(i,w)^f)*notallowed(k,w);endif v~=0p(j)=u/v;endendend[pk,j]=max(p);notallowed(k,j)=0;L(k)=L(k)+d(i,j);a(k,t)=j;endt=t+1;endfor k=1:mL(k)=L(k)+d(a(k,n),a(k,1));end%一次循环结束,回到起始位置%更新for k=1:mfor i=1:n-1s(a(k,i),a(k,i+1),k)=Q/L(k);ends(a(k,n),a(k,1),k)=Q/L(k);endfor i=1:nfor j=1:nif d(i,j)~=inffor k=1:mS1(i,j)=S1(i,j)+s(i,j,k);endendendendfor i=1:nfor j=1:nif d(i,j)~=infS(i,j)=(1-rand)*S(i,j)+S1(i,j);endendendfor k=1:m %将禁忌表中除起始城市，全都置为未访问for t=1:nif t~=a(k,1)notallowed(k,t)=1;endendendS1=zeros(n,n);%（i，j）路段信息素增量清零s=zeros(n,n,m);%s（i，j,k）蚂蚁k在路径i，j上残留的信息素清零end %循环最大次数结束[result,k]=min(L)a(k,:)。

用ACO 算法求解机器人路径优化问题4.1 问题描述移动机器人路径规划是机器人学的一个重要研究领域。

它要求机器人依据某个或某些优化原则(如最小能量消耗，最短行走路线，最短行走时间等)，在其工作空间中找到一条从起始状态到目标状态的能避开障碍物的最优路径。

机器人路径规划问题可以建模为一个有约束的优化问题，都要完成路径规划、定位和避障等任务。

4.2 算法理论蚁群算法（Ant Colony Algorithm，ACA），最初是由意大利学者Dorigo M. 博士于1991 年首次提出，其本质是一个复杂的智能系统，且具有较强的鲁棒性，优良的分布式计算机制等优点。

该算法经过十多年的发展，已被广大的科学研究人员使用于各种问题的研究，如旅行商问题，二次规划问题，生产调度问题等。

但是算法本身性能的评价等算法理论研究方面进展较慢。

Dorigo 提出了精英蚁群模型（EAS），在这一模型中信息素更新按照得到当前最优解的蚂蚁所构造的解来进行，但这样的策略往往使进化变得缓慢，并不能取得较好的效果。

次年Dorigo 博士在文献[30]中给出改进模型（ACS），文中改进了转移概率模型，并且使用了全局搜索和局部搜索策略，来得进行深度搜索。

Stützle 和Hoos给出了最大-最小蚂蚁系统（MAX-MINAS），所谓最大-最小即是为信息素设定上限和下限，设定上限避免搜索陷入局部最优，设定下限鼓励深度搜索。

蚂蚁作为一个生物个体其自身的能力是十分有限的，比如蚂蚁个体是没有视觉的，蚂蚁自身体积又是那么渺小，但是由这些能力有限的蚂蚁组成的蚁群却可以做出超越个体蚂蚁能力的超常行为。

蚂蚁没有视觉却可以寻觅食物，蚂蚁体积渺小而蚁群却可以搬运比它们个体大十倍甚至百倍的昆虫。

这些都说明蚂蚁群体内部的某种机制使得它们具有了群体智能，可以做到蚂蚁个体无法实现的事情。

经过生物学家的长时间观察发现，蚂蚁是通过分泌于空间中的信息素进行信息交流，进而实现群体行为的。

基于蚁群算法的机器人路径规划MA TLAB源码收藏使用网格离散化的方法对带有障碍物的环境建模，使用邻接矩阵存储该环境，使得问题转化为蚁群算法寻找最短路径。

function [ROUTES,PL,Tau]=ACASPS(G,Tau,K,M,S,E,Alpha,Beta,Rho,Q)%% ---------------------------------------------------------------% ACASP.m% 蚁群算法动态寻路算法%% ---------------------------------------------------------------% 输入参数列表% G 地形图为01矩阵，如果为1表示障碍物% Tau 初始信息素矩阵（认为前面的觅食活动中有残留的信息素）% K 迭代次数（指蚂蚁出动多少波）% M 蚂蚁个数（每一波蚂蚁有多少个）% S 起始点（最短路径的起始点）% E 终止点（最短路径的目的点）% Alpha 表征信息素重要程度的参数% Beta 表征启发式因子重要程度的参数% Rho 信息素蒸发系数% Q 信息素增加强度系数%% 输出参数列表% ROUTES 每一代的每一只蚂蚁的爬行路线% PL 每一代的每一只蚂蚁的爬行路线长度% Tau 输出动态修正过的信息素%% --------------------变量初始化----------------------------------%loadD=G2D(G);N=size(D,1);%N表示问题的规模（象素个数）MM=size(G,1);a=1;%小方格象素的边长Ex=a*(mod(E,MM)-0.5);%终止点横坐标if Ex==-0.5Ex=MM-0.5;endEy=a*(MM+0.5-ceil(E/MM));%终止点纵坐标Eta=zeros(1,N);%启发式信息，取为至目标点的直线距离的倒数%下面构造启发式信息矩阵for i=1:Nix=a*(mod(i,MM)-0.5);if ix==-0.5ix=MM-0.5;endiy=a*(MM+0.5-ceil(i/MM));if i~=EEta(1,i)=1/((ix-Ex)^2+(iy-Ey)^2)^0.5;elseEta(1,i)=100;endendROUTES=cell(K,M);%用细胞结构存储每一代的每一只蚂蚁的爬行路线PL=zeros(K,M);%用矩阵存储每一代的每一只蚂蚁的爬行路线长度%% -----------启动K轮蚂蚁觅食活动，每轮派出M只蚂蚁-------------------- for k=1:K%disp(k);for m=1:M%% 第一步：状态初始化W=S;%当前节点初始化为起始点Path=S;%爬行路线初始化PLkm=0;%爬行路线长度初始化TABUkm(S)=0;%已经在初始点了，因此要排除DD=D;%邻接矩阵初始化%% 第二步：下一步可以前往的节点DW=DD(W,:);DW1=find(DW<inf);for j=1:length(DW1)if TABUkm(DW1(j))==0endendLJD=find(DW<inf);%可选节点集Len_LJD=length(LJD);%可选节点的个数%% 觅食停止条件：蚂蚁未遇到食物或者陷入死胡同while W~=E&&Len_LJD>=1%% 第三步：转轮赌法选择下一步怎么走PP=zeros(1,Len_LJD);for i=1:Len_LJDendPP=PP/(sum(PP));%建立概率分布Pcum=cumsum(PP);Select=find(Pcum>=rand);to_visit=LJD(Select(1));%下一步将要前往的节点%% 第四步：状态更新和记录Path=[Path,to_visit];%路径增加PLkm=PLkm+DD(W,to_visit);%路径长度增加W=to_visit;%蚂蚁移到下一个节点for kk=1:Nif TABUkm(kk)==0DD(W,kk)=inf;DD(kk,W)=inf;endendTABUkm(W)=0;%已访问过的节点从禁忌表中删除DW=DD(W,:);LJD=find(DW<inf);%可选节点集Len_LJD=length(LJD);%可选节点的个数end%% 第五步：记下每一代每一只蚂蚁的觅食路线和路线长度ROUTES{k,m}=Path;if Path(end)==EPL(k,m)=PLkm;elsePL(k,m)=inf;endend%% 第六步：更新信息素Delta_Tau=zeros(N,N);%更新量初始化for m=1:Mif PL(k,m)<infROUT=ROUTES{k,m};TS=length(ROUT)-1;%跳数PL_km=PL(k,m);for s=1:TSx=ROUT(s);y=ROUT(s+1);Delta_Tau(x,y)=Delta_Tau(x,y)+Q/PL_km;Delta_Tau(y,x)=Delta_Tau(y,x)+Q/PL_km;endendendTau=(1-Rho).*Tau+Delta_Tau;%信息素挥发一部分，新增加一部分end%% ---------------------------绘图--------------------------------plotif=0;%是否绘图的控制参数if plotif==1%绘收敛曲线meanPL=zeros(1,K);minPL=zeros(1,K);for i=1:KPLK=PL(i,:);Nonzero=find(PLK<inf);PLKPLK=PLK(Nonzero);meanPL(i)=mean(PLKPLK);minPL(i)=min(PLKPLK);endfigure(1)plot(minPL);hold onplot(meanPL);grid ontitle('收敛曲线（平均路径长度和最小路径长度）'); xlabel('迭代次数');ylabel('路径长度');%绘爬行图figure(2)axis([0,MM,0,MM])for i=1:MMfor j=1:MMif G(i,j)==1x1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[0.2,0.2,0.2]);hold onelsex1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[1,1,1]);hold onendendendhold onROUT=ROUTES{K,M};Rx=ROUT;Ry=ROUT;for ii=1:LENROUTRx(ii)=a*(mod(ROUT(ii),MM)-0.5);if Rx(ii)==-0.5Rx(ii)=MM-0.5;endRy(ii)=a*(MM+0.5-ceil(ROUT(ii)/MM));endplot(Rx,Ry)endplotif2=0;%绘各代蚂蚁爬行图if plotif2==1figure(3)axis([0,MM,0,MM])for i=1:MMfor j=1:MMif G(i,j)==1x1=j-1;y1=MM-i;x2=j;y2=MM-i;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[0.2,0.2,0.2]);hold onelsex1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[1,1,1]);hold onendendendfor k=1:KPLK=PL(k,:);minPLK=min(PLK);pos=find(PLK==minPLK);m=pos(1);ROUT=ROUTES{k,m};LENROUT=length(ROUT);Rx=ROUT;Ry=ROUT;for ii=1:LENROUTRx(ii)=a*(mod(ROUT(ii),MM)-0.5);if Rx(ii)==-0.5Rx(ii)=MM-0.5;endRy(ii)=a*(MM+0.5-ceil(ROUT(ii)/MM));endplot(Rx,Ry)hold onendend。

function[R_best,L_best,L_ave,Shortest_Route,Shortest_Length]=ACATSP(C,NC_max,m,Alpha,Beta,Rho ,Q)%% 主要符号说明%% C n个城市的坐标，n×2的矩阵%% NC_max 最大迭代次数%% m 蚂蚁个数%% Alpha 表征信息素重要程度的参数%% Beta 表征启发式因子重要程度的参数%% Rho 信息素蒸发系数%% Q 信息素增加强度系数%% R_best 各代最佳路线%% L_best 各代最佳路线的长度%%第一步：变量初始化n=size(C,1); %n表示问题的规模（城市个数）D=zeros(n,n); %D用来存储各个城市之间的欧式距离%%以下计算任意2个城市间的距离，存储到D中for i=1:nfor j=1:nif i~=j %若i，j不重合，即为不同城市D(i,j)=((C(i,1)-C(j,1))^2+(C(i,2)-C(j,2))^2)^0.5; %计算欧氏距离，任意城市i与j的距离elseD(i,j)=eps;%i=j时不计算，应该为0，但后面的启发因子要取倒数，%用eps（浮点相对精度）表示eps=2.2204e-016，一个极小的数字end %if i~=jD(j,i)=D(i,j); %对称矩阵对称TSP问题end % for j=1:nend % for i=1:nEta=1./D; %Eta为能见度因子，这里设为距离的倒数Tau=ones(n,n); %Tau为信息素矩阵默认一开始为1 一个常数Tabu=zeros(m,n); %存储并记录路径的生成第m只蚂蚁访问的第n座城市是城市xNC=1; %迭代计数器，记录迭代次数R_best=zeros(NC_max,n); %各代最佳路线假定为100代，31个城市，即从1-31-1一个线路L_best=inf.*ones(NC_max,1); %各代最佳路线的长度L_ave=zeros(NC_max,1); %各代路线的平均长度while NC<=NC_max %停止条件之一：达到最大迭代次数，停止%%第二步：将m只蚂蚁放到n个城市上Randpos=[]; %建立一个随机矩阵用以将m只蚂蚁放置到n个城市上for i=1:(ceil(m/n)) %ceil() 向上取整数，去掉小数部分，整数部分+1Randpos=[Randpos,randperm(n)]; %randperm(n),随机产生1~n的序列即得到初始城市m个endTabu(:,1)=(Randpos(1,1:m))';% Tabu(:,1)所有行的第一列，Randpos(1,1:m)’第一行的1~m列，将Randpos的第一行1~m列，%共m个元素赋给矩阵Tabu的第一列，Tabu为m*n矩阵。

%蚁群算法求解中国TSP问题(48个城市）%%清空环境变量clear allclc%%导入数据load distance_48.txtcitys=distance_48;%%计算城市间互相距离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%%初始化参数ticm=30;%蚂蚁数量alpha=1;%信息素重要程度因子beta=5;%启发函数重要程度因子rho=0.1;%信息素挥发因子Q=1;%常系数Eta=1./D;%启发函数Tau=ones(n,n);%信息素矩阵Table=zeros(m,n);%路径记录表iter=1;%迭代次数初值iter_max=200;%最大迭代次数Route_best=zeros(iter_max,n);%各代最佳路径Length_best=zeros(iter_max,1);%各代最佳路径的长度Length_ave=zeros(iter_max,1);%各代路径的平均长度%%迭代寻找最佳路径while iter<=iter_max%随机产生各个蚂蚁的起点城市start=zeros(m,1);for i=1:mtemp=randperm(n);%随机产生1到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,:);%第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);%iter次的最短路径距离等于当前迭代的最短路径距离与上一次迭代最短路径距离中的最小值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/Len gth(i);endTau=(1-rho)*Tau+Delta_Tau;%迭代次数加1，清空路径记录表iter=iter+1;Table=zeros(m,n);end%%结果显示[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(Shorte st_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('各代最短距离与平均距离对比')toc。

蚁群算法最短路径matlab程序 - 副本蚁群算法最短路径通用Matlab程序下面的程序是蚁群算法在最短路中的应用，稍加扩展即可应用于机器人路径规划function [ROUTES,PL,Tau]=ACASP(G,Tau,K,M,S,E,Alpha,Beta,Rho,Q) D=G2D(G);N=size(D,1);%N表示问题的规模(象素个数) MM=size(G,1);a=1;%小方格象素的边长Ex=a*(mod(E,MM)-0.5);%终止点横坐标if Ex==-0.5Ex=MM-0.5;endEy=a*(MM+0.5-ceil(E/MM)); Eta=zeros(1,N); for i=1:N if ix==-0.5 ix=MM-0.5;endiy=a*(MM+0.5-ceil(i/MM)); if i~=EEta(1,i)=1/((ix-Ex)^2+(iy-Ey)^2)^0.5;elseEta(1,i)=100;endendROUTES=cell(K,M);PL=zeros(K,M);%% -----------启动K轮蚂蚁觅食活动，每轮派出M只蚂蚁--------------------for k=1:Kdisp(k);for m=1:MW=S;Path=S;PLkm=0;TABUkm=ones(1,N);TABUkm(S)=0;DD=D;DW=DD(W,:);DW1=find(DW)for j=1:length(DW1)if TABUkm(DW1(j))==0 DW(j)=inf;endendLJD=find(DWLen_LJD=length(LJD); while W~=E&&Len_LJD>=1 PP=zeros(1,Len_LJD); for i=1:Len_LJDPP(i)=(Tau(W,LJD(i))^Alpha)*(Eta(LJD(i))^Beta);endPP=PP/(sum(PP)); Pcum=cumsum(PP);Select=find(Pcum>=rand);Path=[Path,to_visit]; PLkm=PLkm+DD(W,to_visit); W=to_visit;for kk=1:Nif TABUkm(kk)==0 DD(W,kk)=inf;DD(kk,W)=inf;endendTABUkm(W)=0;for j=1:length(DW1)if TABUkm(DW1(j))==0DW(j)=inf;endendLJD=find(DWLen_LJD=length(LJD);%可选节点的个数 end ROUTES{k,m}=Path; if Path(end)==EPL(k,m)=PLkm;elsePL(k,m)=inf;endendDelta_Tau=zeros(N,N);%更新量初始化for m=1:Mif PL(k,m) ROUT=ROUTES{k,m};TS=length(ROUT)-1;%跳数PL_km=PL(k,m);for s=1:TSx=ROUT(s);Delta_Tau(x,y)=Delta_Tau(x,y)+Q/PL_km;Delta_Tau(y,x)=Delta_Tau(y,x)+Q/PL_km;endendendTau=(1-Rho).*Tau+Delta_Tau;%信息素挥发一部分，新增加一部分 end %% ---------------------------绘图-------------------------------- plotif=1;%是否绘图的控制参数if plotif==1%绘收敛曲线meanPL=zeros(1,K);minPL=zeros(1,K);for i=1:KPLK=PL(i,:);Nonzero=find(PLKPLKPLK=PLK(Nonzero);meanPL(i)=mean(PLKPLK);minPL(i)=min(PLKPLK);endfigure(1)plot(minPL);hold onplot(meanPL);grid ontitle('收敛曲线(平均路径长度和最小路径长度)'); xlabel('迭代次数');ylabel('路径长度');%绘爬行图figure(2)axis([0,MM,0,MM])for i=1:MMfor j=1:MMif G(i,j)==1x1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[0.2,0.2,0.2]); hold onelsex1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[1,1,1]); hold onendendendhold onROUT=ROUTES{K,M};LENROUT=length(ROUT);Rx=ROUT;Ry=ROUT;for ii=1:LENROUTRx(ii)=a*(mod(ROUT(ii),MM)-0.5);if Rx(ii)==-0.5Rx(ii)=MM-0.5;endRy(ii)=a*(MM+0.5-ceil(ROUT(ii)/MM));endplot(Rx,Ry)endplotif2=1;%绘各代蚂蚁爬行图if plotif2==1figure(3)axis([0,MM,0,MM])for i=1:MMfor j=1:MMif G(i,j)==1x1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[0.2,0.2,0.2]); hold onelsex1=j-1;y1=MM-i;x2=j;y2=MM-i;x3=j;y3=MM-i+1;x4=j-1;y4=MM-i+1;fill([x1,x2,x3,x4],[y1,y2,y3,y4],[1,1,1]);hold onendendendfor k=1:KPLK=PL(k,:);minPLK=min(PLK);pos=find(PLK==minPLK);m=pos(1);ROUT=ROUTES{k,m};LENROUT=length(ROUT);Rx=ROUT;Ry=ROUT;for ii=1:LENROUTRx(ii)=a*(mod(ROUT(ii),MM)-0.5);if Rx(ii)==-0.5Rx(ii)=MM-0.5;endRy(ii)=a*(MM+0.5-ceil(ROUT(ii)/MM));endplot(Rx,Ry)hold onendend将上述算法应用于机器人路径规划，优化效果如下图所示。

蚁群算法MATLAB解VRP问题Excel exp12_3_2.xls内容：ANT_VRP函数：function [R_best,L_best,L_ave,Shortest_Route,Shortest_Length]=ANT_VRP(D,Demand,Cap,iter_max,m,Alpha,Beta,Rho,Q) %% R_best 各代最佳路线%% L_best 各代最佳路线的长度%% L_ave 各代平均距离%% Shortest_Route 最短路径%% Shortest_Length 最短路径长度%% D 城市间之间的距离矩阵，为对称矩阵%% Demand 客户需求量%% Cap 车辆最⼤载重%% iter_max 最⼤迭代次数%% m 蚂蚁个数%% Alpha 表征信息素重要程度的参数%% Beta 表征启发式因⼦重要程度的参数%% Rho 信息素蒸发系数%% Q 信息素增加强度系数n=size(D,1);T=zeros(m,2*n); %装载距离Eta=ones(m,2*n); %启发因⼦Tau=ones(n,n); %信息素Tabu=zeros(m,n); %禁忌表Route=zeros(m,2*n); %路径L=zeros(m,1); %总路程L_best=zeros(iter_max,1); %各代最佳路线长度R_best=zeros(iter_max,2*n); %各代最佳路线nC=1;while nC<=iter_max %停⽌条件Eta=zeros(m,2*n);T=zeros(m,2*n);Tabu=zeros(m,n);Route=zeros(m,2*n);L=zeros(m,1);%%%%%%==============初始化起点城市（禁忌表）====================for i=1:mCap_1=Cap; %最⼤装载量j=1;j_r=1;while Tabu(i,n)==0T=zeros(m,2*n); %装载量加载矩阵Tabu(i,1)=1; %禁忌表起点位置为1Route(i,1)=1; %路径起点位置为1visited=find(Tabu(i,:)>0); %已访问城市num_v=length(visited); %已访问城市个数J=zeros(1,(n-num_v)); %待访问城市加载表P=J; %待访问城市选择概率分布Jc=1; %待访问城市选择指针for k=1:n %城市if length(find(Tabu(i,:)==k))==0 %如果k不是已访问城市代号，就将k加⼊矩阵J中J(Jc)=k;Jc=Jc+1;endend%%%%%%%=============每只蚂蚁按照选择概率遍历所有城市==================for k=1:n-num_v %待访问城市if Cap_1-Demand(J(1,k),1)>=0 %如果车辆装载量⼤于待访问城市需求量if Route(i,j_r)==1 %如果每只蚂蚁在起点城市T(i,k)=D(1,J(1,k));P(k)=(Tau(1,J(1,k))^Alpha)*((1/T(i,k))^Beta); %概率计算公式中的分⼦else %如果每只蚂蚁在不在起点城市T(i,k)=D(Tabu(i,j),J(1,k));P(k)=(Tau(Tabu(i,visited(end)),J(1,k))^Alpha)*((1/T(i,k))^Beta); %概率计算公式中的分⼦endelse %如果车辆装载量⼩于待访问城市需求量T(i,k)=0;P(k)=0;endendif length(find(T(i,:)>0))==0 %%%当车辆装载量⼩于待访问城市时，选择起点为1Cap_1=Cap;j_r=j_r+1;Route(i,j_r)=1;L(i)=L(i)+D(1,Tabu(i,visited(end)));elseP=P/(sum(P)); %按照概率原则选取下⼀个城市Pcum=cumsum(P); %求累积概率和：cumsum（[1 2 3])=1 3 6,⽬的在于使得Pcum的值总有⼤于rand的数Select=find(Pcum>rand); %按概率选取下⼀个城市：当累积概率和⼤于给定的随机数，则选择求和被加上的最后⼀个城市作为即将访问的城市 o_visit=J(1,Select(1)); %待访问城市j=j+1;j_r=j_r+1;Tabu(i,j)=o_visit; %待访问城市Route(i,j_r)=o_visit;Cap_1=Cap_1-Demand(o_visit,1); %车辆装载剩余量L(i)=L(i)+T(i,Select(1)); %路径长度endendL(i)=L(i)+D(Tabu(i,n),1); %%路径长度endL_best(nC)=min(L); %最优路径为距离最短的路径pos=find(L==min(L)); %找出最优路径对应的位置：即为哪只蚂蚁R_best(nC,:)=Route(pos(1),:); %确定最优路径对应的城市顺序L_ave(nC)=mean(L)'; %求第k次迭代的平均距离Delta_Tau=zeros(n,n); %Delta_Tau(i,j)表⽰所有蚂蚁留在第i个城市到第j个城市路径上的信息素增量L_zan=L_best(1:nC,1);post=find(L_zan==min(L_zan));Cities=find(R_best(nC,:)>0);num_R=length(Cities);for k=1:num_R-1 %建⽴了完整路径后在释放信息素Delta_Tau(R_best(nC,k),R_best(nC,k+1))=Delta_Tau(R_best(nC,k),R_best(nC,k+1))+Q/L_best(nC);endDelta_Tau(R_best(nC,num_R),1)=Delta_Tau(R_best(nC,num_R),1)+Q/L_best(nC);Tau=Rho*Tau+Delta_Tau;nC=nC+1;endShortest_Route=zeros(1,2*n); %提取最短路径Shortest_Route(1,:)=R_best(iter_max,:);Shortest_Route=Shortest_Route(Shortest_Route>0);Shortest_Route=[Shortest_Route Shortest_Route(1,1)];Shortest_Length=min(L_best); %提取最短路径长度%L_ave=mean(L_best); 求解程序：clc;clear all%% ==============提取数据==============[xdata,textdata]=xlsread('exp12_3_2.xls'); %加载20个城市的数据，数据按照表格中位置保存在Excel⽂件exp12_3_1.xls中x_label=xdata(:,2); %第⼆列为横坐标y_label=xdata(:,3); %第三列为纵坐标Demand=xdata(:,4); %第四列为需求量C=[x_label y_label]; %坐标矩阵n=size(C,1); %n表⽰节点（客户）个数%% ==============计算距离矩阵==============D=zeros(n,n); %D表⽰完全图的赋权邻接矩阵，即距离矩阵D初始化for i=1:nfor j=1:nif i~=jD(i,j)=((C(i,1)-C(j,1))^2+(C(i,2)-C(j,2))^2)^0.5; %计算两城市之间的距离elseD(i,j)=0; %i=j, 则距离为0；endD(j,i)=D(i,j); %距离矩阵为对称矩阵endendAlpha=1;Beta=5;Rho=0.75;iter_max=100;Q=10;Cap=1;m=20; %Cap为车辆最⼤载重[R_best,L_best,L_ave,Shortest_Route,Shortest_Length]=ANT_VRP(D,Demand,Cap,iter_max,m,Alpha,Beta,Rho,Q); %蚁群算法求解VRP问题通⽤函数，详见配套光盘Shortest_Route_1=Shortest_Route-1 %提取最优路线Shortest_Length %提取最短路径长度%% ==============作图==============figure(1) %作迭代收敛曲线图x=linspace(0,iter_max,iter_max);y=L_best(:,1);plot(x,y);xlabel('迭代次数'); ylabel('最短路径长度');figure(2) %作最短路径图plot([C(Shortest_Route,1)],[C(Shortest_Route,2)],'o-');grid onfor i =1:size(C,1)text(C(i,1),C(i,2),[' ' num2str(i-1)]);endxlabel('客户所在横坐标'); ylabel('客户所在纵坐标');。

蚁群算法求解TSP问题的MATLAB程序(较好的算例) %蚁群算法求解TSP问题的matlab程序clear allclose allclc%初始化蚁群m=31;%蚁群中蚂蚁的数量，当m接近或等于城市个数n时，本算法可以在最少的迭代次数内找到最优解C=[1304 2312;3639 1315;4177 2244;3712 1399;3488 1535;3326 1556;3238 1229;4196 1004;4312 790;4386 570;3007 1970;2562 1756;2788 1491;2381 1676;1332 695;3715 1678;3918 2179;4061 2370;3780 2212;3676 2578;4029 2838;4263 2931;3429 1908;3507 2367;3394 2643;3439 3201;2935 3240;3140 3550;2545 2357;2778 2826;2370 2975];%城市的坐标矩阵Nc_max=200;%最大循环次数，即算法迭代的次数，亦即蚂蚁出动的拨数(每拨蚂蚁的数量当然都是m)alpha=1;%蚂蚁在运动过程中所积累信息(即信息素)在蚂蚁选择路径时的相对重要程度，alpha过大时，算法迭代到一定代数后将出现停滞现象beta=5;%启发式因子在蚂蚁选择路径时的相对重要程度rho=0.5;%0<rho<1,表示路径上信息素的衰减系数(亦称挥发系数、蒸发系数)，1-rho表示信息素的持久性系数Q=100;%蚂蚁释放的信息素量，对本算法的性能影响不大%变量初始化n=size(C,1);%表示TSP问题的规模，亦即城市的数量D=ones(n,n);%表示城市完全地图的赋权邻接矩阵，记录城市之间的距离 for i=1:nfor j=1:nif i<jD(i,j)=sqrt((C(i,1)-C(j,1))^2+(C(i,2)-C(j,2))^2);endD(j,i)=D(i,j);endendeta=1./D;%启发式因子，这里设为城市之间距离的倒数pheromone=ones(n,n);%信息素矩阵,这里假设任何两个城市之间路径上的初始信息素都为1 tabu_list=zeros(m,n);%禁忌表，记录蚂蚁已经走过的城市，蚂蚁在本次循环中不能再经过这些城市。