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

城市间蚁群算法matlab实现%% I. 清空环境变量clear allclc%% II. 导入数据31个城市的坐标load citys_data.mat%% III. 计算城市间相互距离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; %用很小的值代替0 公式需要endendend%% IV. 初始化参数m = 50; % 蚂蚁数量alpha = 1; % 信息素重要程度因子beta = 5; % 启发函数重要程度因子rho = 0.1; % 信息素挥发因子Q = 1; % 常系数Eta = 1./D; % 启发函数Tau = ones(n,n); % 信息素矩阵Table = zeros(m,n); % 路径记录表m个蚂蚁走过的路径iter = 1; % 迭代次数初值iter_max = 200; % 最大迭代次数Route_best = zeros(iter_max,n); % 各代最佳路径Length_best = zeros(iter_max,1); % 各代最佳路径的长度Length_ave = zeros(iter_max,1); % 各代路径的平均长度%% V. 迭代寻找最佳路径while iter <= iter_max% 随机产生各个蚂蚁的起点城市start = zeros(m,1);for i = 1:m %50个蚂蚁随机产生的起始城市位置temp = 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; %end代表最后一个元素对应公式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，清空路径记录表iter = iter + 1;Table = zeros(m,n);end%% VI. 结果显示[Shortest_Length,index] = min(Length_best);Shortest_Route = Route_best(index,:);disp(['最短距离:' num2str(Shortest_Length)]);disp(['最短路径:' num2str([Shortest_Route Shortest_Route(1)])]);%% VII. 绘图1960009019 l132********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('各代最短距离与平均距离对比')。

%% 蚁群算法¨clearcloseclcn = 10; % 城市数量m = 100; % 蚂蚁数量alfa = 1.5;beta = 2.5;rho = 0.1;Q = 1000;maxgen = 50;x = [2 14 9 6 3 2 4 8 12 5]';y = [8 9 12 4 1 2 5 8 1 15]';% x =[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]';% y =[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]';City = [x,y]; % 城市坐标%% 城市之间的距离for i = 1:nD(i,:) = ((City(i,1) - City(:,1)).^2 + (City(i,2) - City(:,2)).^2).^0.5 + eps; endeta = 1./D; % 启发因子tau = ones(n); % 信息素矩阵path = zeros(m,n); % 记录路径for iter = 1: maxgen%% 放置蚂蚁path(:,1) = randi([1 n],m,1);for i = 2 : nfor j = 1 : mvisited = path(j,1:i-1);leftcity = setdiff(1:n,visited);%% 计算剩下城市的概率P = zeros(1,length(leftcity));for k = 1:length(leftcity)P(k) =tau(visited(end),leftcity(k))^alfa*eta(visited(end),leftcity(k))^beta;%判断是否有重复城市endP1 = sum(P);Pk = P / P1;P = cumsum(Pk);r = rand;index = find(P >= r);nextcity = leftcity(index(1));path(j,i) = nextcity;endendfor flag = 1:mif length(unique(path(flag,:))) ~= n %keyboard;endendif iter >= 2path(1,:) = Pathbest(iter-1,:);endfor i = 1 : mnode = path(i,:);d = 0;for j = 1 : n - 1d = d + D(node(j),node(j + 1));endL(i) = d;end[shortroute,antindex] = min(L);Lbest(iter) = shortroute;Pathbest(iter,:) = path(antindex,:);detatau = zeros(n);for i = 1 : mfor j = 1 : n-1detatau(path(i,j),path(i,j + 1)) = detatau(path(i,j),path(i,j + 1)) + Q/L(i);detatau(path(i,j + 1),path(i,j))=detatau(path(i,j),path(i,j + 1));enddetatau(path(i,n),path(i,1)) = detatau(path(i,n),path(i,1)) + Q/L(i);detatau(path(i,1),path(i,n))=detatau(path(i,n),path(i,1));endtau = (1 - rho)*tau + detatau;path = zeros(m,n);endindex = find(Lbest == min(Lbest));shortestpath = Pathbest(index(1),:);shortestdistance = Lbest(index(1))subplot(1,2,1)plot(x,y,'o')hold onfor i = 1 : n - 1firstcity = shortestpath(i);nextcity = shortestpath(i + 1);plot([x(firstcity),x(nextcity)],[y(firstcity),y(nextcity)],'b');endfirstcity = shortestpath(n);nextcity = shortestpath(1);plot([x(firstcity),x(nextcity)],[y(firstcity),y(nextcity)],'b');axis equalaxis([0 18 0 18])subplot(1,2,2)plot(Lbest)hold ontitle('×î¶Ì¾àÀë')。

基于蚁群算法的机器人路径规划MATLAB源代码基本思路是，使用离散化网格对带有障碍物的地图环境建模，将地图环境转化为邻接矩阵，最后使用蚁群算法寻找最短路径。

function [ROUTES,PL,Tau]=ACASPS(G,Tau,K,M,S,E,Alpha,Beta,Rho,Q)%% ---------------------------------------------------------------% ACASP.m% 基于蚁群算法的机器人路径规划% GreenSim团队——专业级算法设计&代写程序% 欢迎访问GreenSim团队主页→%% ---------------------------------------------------------------% 输入参数列表% 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源代码运行结果展示。

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程序）蚁群算法与模拟退火算法对旅游路线问题的探究张煊张恒伟徐晓辉摘要：本文针对旅游中国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⽂件加载数据：运⾏结果：。

蚁群算法介绍：(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 。

%% 蚁群算法¨clearcloseclcn = 10; % 城市数量m = 100; % 蚂蚁数量alfa = 1.5;beta = 2.5;rho = 0.1;Q = 1000;maxgen = 50;x = [2 14 9 6 3 2 4 8 12 5]';y = [8 9 12 4 1 2 5 8 1 15]';% x =[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]';% y =[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]';City = [x,y]; % 城市坐标%% 城市之间的距离for i = 1:nD(i,:) = ((City(i,1) - City(:,1)).^2 + (City(i,2) - City(:,2)).^2).^0.5 + eps; endeta = 1./D; % 启发因子tau = ones(n); % 信息素矩阵path = zeros(m,n); % 记录路径for iter = 1: maxgen%% 放置蚂蚁path(:,1) = randi([1 n],m,1);for i = 2 : nfor j = 1 : mvisited = path(j,1:i-1);leftcity = setdiff(1:n,visited);%% 计算剩下城市的概率P = zeros(1,length(leftcity));for k = 1:length(leftcity)P(k) =tau(visited(end),leftcity(k))^alfa*eta(visited(end),leftcity(k))^beta;%判断是否有重复城市endP1 = sum(P);Pk = P / P1;P = cumsum(Pk);r = rand;index = find(P >= r);nextcity = leftcity(index(1));path(j,i) = nextcity;endendfor flag = 1:mif length(unique(path(flag,:))) ~= n %keyboard;endendif iter >= 2path(1,:) = Pathbest(iter-1,:);endfor i = 1 : mnode = path(i,:);d = 0;for j = 1 : n - 1d = d + D(node(j),node(j + 1));endL(i) = d;end[shortroute,antindex] = min(L);Lbest(iter) = shortroute;Pathbest(iter,:) = path(antindex,:);detatau = zeros(n);for i = 1 : mfor j = 1 : n-1detatau(path(i,j),path(i,j + 1)) = detatau(path(i,j),path(i,j + 1)) + Q/L(i);detatau(path(i,j + 1),path(i,j))=detatau(path(i,j),path(i,j + 1));enddetatau(path(i,n),path(i,1)) = detatau(path(i,n),path(i,1)) + Q/L(i);detatau(path(i,1),path(i,n))=detatau(path(i,n),path(i,1));endtau = (1 - rho)*tau + detatau;path = zeros(m,n);endindex = find(Lbest == min(Lbest));shortestpath = Pathbest(index(1),:);shortestdistance = Lbest(index(1))subplot(1,2,1)plot(x,y,'o')hold onfor i = 1 : n - 1firstcity = shortestpath(i);nextcity = shortestpath(i + 1);plot([x(firstcity),x(nextcity)],[y(firstcity),y(nextcity)],'b');endfirstcity = shortestpath(n);nextcity = shortestpath(1);plot([x(firstcity),x(nextcity)],[y(firstcity),y(nextcity)],'b');axis equalaxis([0 18 0 18])subplot(1,2,2)plot(Lbest)hold ontitle('×î¶Ì¾àÀë')。

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

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

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

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

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

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

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应用作业报告1 设计题目蚁群算法2 引言2.1 蚁群算法简介20世纪50年代中期创立了仿生学，人们从生物进化的机理中受到启发。

提出了许多用以解决复杂优化问题的新方法，如进化规划、进化策略、遗传算法等，这些算法成功地解决了一些实际问题。

20世纪90年代意大利学者M．Dorigo，V．Maniezzo，A．Colorni等从生物进化的机制中受到启发，通过模拟自然界蚂蚁搜索路径的行为，提出来一种新型的模拟进化算法——蚁群算法，是群智能理论研究领域的一种主要算法。

用该方法求解TSP问题、分配问题、job-shop 调度问题，取得了较好的试验结果．虽然研究时间不长，但是现在的研究显示出，蚁群算法在求解复杂优化问题（特别是离散优化问题）方面有一定优势，表明它是一种有发展前景的算法．2.2 研究现状90年代Dorigo最早提出了蚁群优化算法---蚂蚁系统（Ant System, AS）并将其应用于解决计算机算法学中经典的旅行商问题（TSP）。

从蚂蚁系统开始，基本的蚁群算法得到了不断的发展和完善，并在TSP以及许多实际优化问题求解中进一步得到了验证。

这些AS改进版本的一个共同点就是增强了蚂蚁搜索过程中对最优解的探索能力，它们之间的差异仅在于搜索控制策略方面。

而且，取得了最佳结果的ACO是通过引入局部搜索算法实现的，这实际上是一些结合了标准局域搜索算法的混合型概率搜索算法，有利于提高蚁群各级系统在优化问题中的求解质量。

最初提出的AS有三种版本：Ant-density、Ant-quantity和Ant-cycle。

在Ant-density 和Ant-quantity中蚂蚁在两个位置节点间每移动一次后即更新信息素，而在Ant-cycle中当所有的蚂蚁都完成了自己的行程后才对信息素进行更新，而且每个蚂蚁所释放的信息素被表达为反映相应行程质量的函数。

通过与其它各种通用的启发式算法相比，在不大于75城市的TSP中，这三种基本算法的求解能力还是比较理想的，但是当问题规模扩展时，AS的解题能力大幅度下降。

基于蚁群算法的机器人路径规划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。

%蚁群算法求解中国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解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);%禁忌表，记录蚂蚁已经走过的城市，蚂蚁在本次循环中不能再经过这些城市。