蚁群算法c语言

合集下载

c++蚁群算法最短路径代码

c++蚁群算法最短路径代码
if (temp) {
temp=pow((1.0/Map.distance[curCity][i]),beta)*pow((Map.m_dTrial[curCity][i]),alpha);
j=i;
}
}
}
return j;
}
ant::ant()
double sel=0;
for (i=0;i<iCityCount;i++)
{
if(Map.distance[curCity][i]&&(AllowedCity[i]==1))
{
prob[i]=pow((1.0/Map.distance[curCity][i]),beta)*pow((Map.m_dTrial[curCity][i]),alpha)/temp;
int i;
for(i=0;tabu[i]!=iCityCount-1;i++)
m_dLength+=Map.distance[tabu[i]][tabu[i+1]];
}
int ant::move()
{
//the ant move to next town and add town ID to tabu.
{
for (j=0;ants[i].tabu[j]!=iCityCount-1&&rValue[j]!=-1;j++)
{
Map.m_dDeltTrial[ants[i].tabu[j]][ants[i].tabu[j+1]]+=Q/ants[i].m_dLength ;
Map.m_dDeltTrial[ants[i].tabu[j+1]][ants[i].tabu[j]]+=Q/ants[i].m_dLength;

蚂蚁算法

蚂蚁算法

蚂蚁算法求解TSP问题指导教师:李正学系 别:应用数学系班 级:2003级06班姓 名:王源学 号:200312082蚂蚁算法求解TSP问题摘 要蚂蚁算法是通过蚂蚁觅食而发展出的一种新的启发算法,该算法已经成功的解决了诸如TSP问题。

本文简要学习探讨了蚂蚁算法和TSP问题的基本内容,尝试解决一个实例问题并给出C语言算法。

关键词蚂蚁算法;TSP问题。

1 蚂蚁算法与TSP问题1.1 蚂蚁算法蚂蚁算法(Ant Colony Algorithm) 是由意大利学者M.Dorigo ,V. Manierio ,A. Collorni等人于二十世纪九十年代提出的一种新型的模拟进化算法。

受到人们对自然界中真实蚁群集体行为研究成果的启发,考虑到蚁群搜索食物的过程与旅行商问题的相似性,利用蚁群算法求解旅行商问题(Traveling Salesman Problem,TSP ) 、指派问题(AssignmentProblem)和调度问题( Scheduling Problem) ,取得了一些比较满意的实验结果。

蚁群算法是一种适应性好、鲁棒性强,具有正反馈结构的并行算法。

这些初步研究已显示出蚁群算法在求解复杂优化问题(特别是离散优化问题)方面的一些优越性,证明它是一种很有发展前景的方法。

蚂蚁算法在各个领域的应用,说明该算法有着广泛的适应性,但由于该算法出现的较晚,对其研究还处于起步阶段,远不如遗传算法、人工神经网络和模拟退火算法那样成熟。

算法的很多特性,如算法的收敛性,参数的设定都来自于大量实验统计结果,目前对该算法理论研究有待进一步加强。

经过研究发现,蚂蚁在觅食的过程中通过一种称之为信息素(Pheromone)的物质相互传递信息。

更具体地,蚂蚁在运动过程中能够在其所经过的路径上留下信息素,而且在运动过程中能够感受到这种信息素的存在及其强度,并以此指导自己的运动方向。

蚂蚁倾向于朝着信息素浓度高的方向前进,因此,由大量蚂蚁组成的蚁群的行为便表现出一种信息的正反馈现象:某一路径上走过的蚂蚁越多,则后来者选择该路径的概率就越大。

蚁群算法附带数据结果

蚁群算法附带数据结果

[代码说明]蚁群算法解决VRP问题[算法说明]首先实现一个ant蚂蚁类,用此蚂蚁类实现搜索。

算法按照tsp问题去解决,但是在最后计算路径的时候有区别。

比如有10个城市,城市1是配送站,蚂蚁搜索的得到的路径是1,3,5,9,4,10,2,6,8,7。

计算路径的时候把城市依次放入派送线路中,每放入一个城市前,检查该城市放入后是否会超过车辆最大载重如果没有超过就放入如果超过,就重新开始一条派送路线……直到最后一个城市放完就会得到多条派送路线这样处理比较简单可以把vrp问题转为tsp问题求解但是实际效果还需要验证。

[作者]Wugsh@2011.12.16wuguangsheng@guangsheng.wu@%}%清除所有变量和类的定义clear;clear classes;%蚁群算法参数(全局变量)global ALPHA; %启发因子global BETA; %期望因子global ANT_COUNT; %蚂蚁数量global CITY_COUNT; %城市数量global RHO; %信息素残留系数!!!global IT_COUNT; %迭代次数global DAry; %两两城市间距离global TAry; %两两城市间信息素global CITYW Ary; %城市货物需求量global VW; %车辆最大载重%===================================================================%设置参数变量值ALPHA=1.0;BETA=2.0;RHO=0.95;IT_COUNT=200;VW=100;%=================================================================== %读取数据并根据读取的数据设置其他参数load data.txt; %从文本文件加载数据city_xy_ary=data(:,2:3); %得到城市的坐标数据CITYW Ary=data(:,4); %得到每个城市的货物需求量CITY_COUNT=length(CITYW Ary); %得到城市数量(包括配送站在内)ANT_COUNT=round(CITY_COUNT*2/3)+1; %根据城市数量设置蚂蚁数量,一般设置为城市数量的2/3%MMAS信息素参数%计算最大信息素和最小信息素之间的比值PBest=0.05; %蚂蚁一次搜索找到最优解的概率temp=PBest^(1/CITY_COUNT);TRate=(1-temp)/((CITY_COUNT/2-1)*temp); %最大信息素和最小信息素之间的比值%信息素的最大最小值开始的时候设置成多大无所谓%第一次搜索完成会生成一个最优解,然后用这个解会重新产生最大最小值Tmax=1; %信息素最大值Tmin=Tmax*TRate; %信息素最小值% 计算两两城市间距离DAry=zeros(CITY_COUNT);for i=1:CITY_COUNTfor j=1:CITY_COUNTDAry(i,j)=sqrt((city_xy_ary(i,1)-city_xy_ary(j,1))^2+(city_xy_ary(i,2)-city_xy_ary(j,2))^2);endend% 初始化城市间信息素TAry=zeros(CITY_COUNT);TAry=TAry+Tmax;%===================================================================%初始化随机种子rand('state', sum(100*clock));%另一种方法%rand('twister',sum(100*clock))%定义蚂蚁mayi=ant();Best_Path_Length=10e9; %最佳路径长度,先设置成一个很大的值tm1=datenum(clock); %记录算法开始执行时的时间FoundBetter=0; %一次搜索是否有更优解产生%开始搜索for i=1:IT_COUNTfprintf('开始第%d次搜索, 剩余%d次',i,IT_COUNT-i);FoundBetter=0; %搜索前先置为没有更优解产生for j=1:ANT_COUNT%蚂蚁搜索一次mayi=Search(mayi);%得到蚂蚁搜索路径长度Length_Ary(j)=get(mayi,'path_length');%得到蚂蚁搜索的路径Path_Ary{j}=get(mayi,'path');%保存最优解if (Length_Ary(j) < Best_Path_Length);Best_Path_Length=Length_Ary(j);Best_Path=Path_Ary{j};%有更优解产生,设置标志FoundBetter=1;endend%有更好解产生,进行2-OPT优化if (FoundBetter == 1)fprintf(' , 本次搜索找到更好解!');Best_Path=opt2(Best_Path);Best_Path_Length=PathLength(Best_Path);end%-------------------------------------------------------------%全部蚂蚁搜索完一次,更新环境信息素TAry=TAry*RHO;%只有全局最优蚂蚁释放信息素dbQ=1/Best_Path_Length;for k=2:CITY_COUNTm=Best_Path(k-1); %上一个城市编号n=Best_Path(k); %下一个城市编号%更新路径上的信息素TAry(m,n)=TAry(m,n)+dbQ;TAry(n,m)=TAry(m,n);end%更新最后城市返回出发城市路径上的信息素TAry(n,1)=TAry(n,1)+dbQ;TAry(1,n)=TAry(n,1);%-------------------------------------------------------------%更新完信息素,进行边界检查Tmax=1/((1-RHO)*Best_Path_Length); %信息素最大值Tmin=Tmax*TRate; %信息素最小值for m=1:CITY_COUNTfor n=1:CITY_COUNTif (TAry(m,n)>Tmax)TAry(m,n)=Tmax;endif (TAry(m,n)<Tmin)TAry(m,n)=Tmin;endendend%-------------------------------------------------------------%换行fprintf('\n');endtm2=datenum(clock); %记录算法结束执行时的时间fprintf('\n搜索完成, 用时%.3f秒, 最佳路径长为%.3f , 派送方案如下::\n\n[1]',(tm2-tm1)*86400,Best_Path_Length);%=================================================================== %输出结果dbW=0;for i=2:CITY_COUNTm=Best_Path(i-1); %上一个城市n=Best_Path(i); %当前城市if (dbW+CITYW Ary(n)>VW) %运送的货物超过限制fprintf(' (满载率: %.1f%%)\n[1]-%d',dbW*100/VW,n);dbW=CITYW Ary(n); %运输的重量等于该城市的需求量else %没有超过限制fprintf('-%d',n);dbW=dbW+CITYWAry(n); %运输的重量加上该城市的需求量endendfprintf(' (满载率: %.1f%%)',dbW*100/VW);fprintf('\n\n');%====== [程序结束]===================================================== %对结果进行2-OPT优化function f=opt2(Line)%数组长度size=length(Line);NewLine=Line; % 返回结果先设置成原来路径Flag=1;while (Flag == 1)Flag=0;for i=1:size-2a=Line(1,1:i); %路径前段b=fliplr(Line(1,i+1:size)); %路径后段倒置c=cat(2,a,b); %新路径%新路径更好就替换if (PathLength(c)<PathLength(NewLine))NewLine=c;Flag=1;fprintf('\n======================= 2-OPT 优化成功! ===');endendend%返回结果f=NewLine;end1 14.5 13.0 0.02 12.8 8.5 0.13 18.4 3.4 0.44 15.4 16.6 1.25 18.9 15.2 1.56 15.5 11.6 0.87 3.9 10.6 1.38 10.6 7.6 1.79 8.6 8.4 0.610 12.5 2.1 1.211 13.8 5.2 0.412 6.7 16.9 0.913 14.8 2.6 1.314 1.8 8.7 1.315 17.1 11.0 1.916 7.4 1.0 1.717 0.2 2.8 1.118 11.9 19.8 1.519 13.2 15.1 1.620 6.4 5.6 1.721 9.6 14.8 1.51 0 0 02 3639 1315 123 4177 2244 134 3712 1399 145 3488 1535 536 3326 1556 457 3238 1229 228 4196 1004 119 4312 790 1110 4386 570 5611 3007 1970 4312 2562 1756 2413 2788 1491 6514 2381 1676 3215 1332 695 5616 3715 1678 6717 3918 2179 6718 4061 2370 2219 3780 2212 3420 3676 2578 5621 4029 2838 2422 4263 2931 2523 3429 1908 2624 3507 2367 4625 3394 2643 8726 3439 3201 3327 2935 3240 2228 3140 3550 2429 2545 2357 5630 2778 2826 2431 2370 2975 4332 1304 2312 12。

蚁群算法——精选推荐

蚁群算法——精选推荐

蚁群算法⼀、蚁群算法蚁群算法是在20世纪90年代由澳⼤利亚学者Marco Dorigo等⼈通过观察蚁群觅⾷的过程,发现众多蚂蚁在寻找⾷物的过程中,总能找到⼀条从蚂蚁巢⽳到⾷物源之间的最短路径。

随后他们在蚂蚁巢⽳到⾷物源之间设置了⼀个障碍,⼀段时间以后发现蚂蚁⼜重新⾛出了⼀条到⾷物源最短的路径。

通过对这种现象的不断研究,最后提出了蚁群算法。

蚁群算法在解决(即TSP问题)时,取得了⽐较理想的结果。

⼆、基本⼈⼯蚁群算法原理运⽤⼈⼯蚁群算法求解TSP问题时的基本原理是:将m个蚂蚁随机地放在多个城市,让这些蚂蚁从所在的城市出发,n步(⼀个蚂蚁从⼀个城市到另外⼀个城市为1步)之后返回到出发的城市。

如果m个蚂蚁所⾛出的m条路经对应的中最短者不是TSP问题的最短路程,则重复这⼀过程,直⾄寻找到满意的TSP问题的最短路径为⽌。

为了说明这⼀个算法下⾯⽤⼀个算法流程图来表⽰⼀下:三、蚁群算法中涉及到的参数及其符号::蚂蚁数量,约为城市数量的1.5倍。

如果蚂蚁数量过⼤,则每条路径上的信息素浓度趋于平均,正反馈作⽤减弱,从⽽导致收敛速度减慢;如果过⼩,则可能导致⼀些从未搜索过的路径信息素浓度减⼩为0,导致过早收敛,解的全局最优性降低:信息素因⼦,反映了蚂蚁运动过程中积累的信息量在指导蚁群搜索中的相对重要程度,取值范围通常在[1, 4]之间。

如果信息素因⼦值设置过⼤,则容易使随机搜索性减弱;其值过⼩容易过早陷⼊局部最优:启发函数因⼦,反映了启发式信息在指导蚁群搜索中的相对重要程度,取值范围在[3, 4.5]之间。

如果值设置过⼤,虽然收敛速度加快,但是易陷⼊局部最优;其值过⼩,蚁群易陷⼊纯粹的随机搜索,很难找到最优解:信息素挥发因⼦,反映了信息素的消失⽔平,相反的反映了信息素的保持⽔平,取值范围通常在[0.2, 0.5]之间。

当取值过⼤时,容易影响随机性和全局最优性;反之,收敛速度降低:信息素常数,表⽰蚂蚁遍历⼀次所有城市所释放的信息素总量。

C#实现蚁群算法

C#实现蚁群算法

/sun_raining61/blog/item/449da9240b1e71024d088d5d.html/cmtid/1056b bed39d4d24779f05502using System;using System.Collections.Generic;using System.Text;namespace AntSystem{public class AA{/**//// <summary>/// 对信息量的重视程度/// </summary>private int alpha;/**//// <summary>/// 启发式信息的受重视程度/// </summary>private int beta;/**//// <summary>/// 信息素的挥发速度/// </summary>private double lo;/**//// <summary>/// 城市距离矩阵/// </summary>private double[,] City;/**//// <summary>/// 信息素矩阵/// </summary>private double[,] Message;/**//// <summary>/// opneList用于存放下一步可行城市/// </summary>private Queue<int> openList=new Queue<int> ();/**//// <summary>/// closedList用于存放已经访问过的城市/// </summary>private Queue<int> closedList=new Queue<int> ();/**//// <summary>/// 储存较好的路径/// </summary>private Queue <int> BestList=new Queue<int> ();private int Pro_time = 0;/**///////////////////////////////////////////////////////////// <summary>/// 构造函数:形成城市距离和信息素矩阵/// </summary>/// <param name="city">城市距离矩阵</param>/// <param name="Lo"> 信息素的挥发速度</param> public AA(double[,] city,double Lo,int Alpha,int Beta) {alpha = Alpha;beta = Beta;lo=Lo;int temp = Convert.ToInt32( Math.Sqrt(city.Length)); City=new double [temp,temp];Message=new double [temp,temp];for (int i = 0; i < temp; i++){for (int j = 0; j < temp; j++){City[i, j] = city[i, j];}}//初始化信息素矩阵for (int i = 0; i < temp; i++){for (int j = 0; j < temp; j++){if (i != j){Message[i, j] = (double)1 / (temp * temp - temp);}}}}/**//////////////////////////////////////////////////////////////// <summary>/// 改变信息素矩阵,closed_list为较好的路径/// </summary>/// <param name="closed_list"></param>private void Change_Message(Queue<int> closed_list) {lock (this){int[] temp_Array = new int[closed_list.Count];temp_Array = closed_list.ToArray();for (int i = 0; i < closed_list.Count - 1; i++){Message[temp_Array[i], temp_Array[i + 1]] = Message[temp_Array[i], temp_Array[i + 1]] + lo / ((1 - lo) *Convert.ToInt32(Get_Weight(closed_list)+1));}Message[temp_Array[temp_Array.Length - 1], temp_Array[0]] = Message[temp_Array[temp_Array.Length - 1], temp_Array[0]] + lo / ((1 - lo) *Convert.ToInt32(Get_Weight(closed_list)));for (int i = 0; i < closed_list.Count; i++){for (int j = 0; j < closed_list.Count; j++){Message[i, j] = (1 - lo) * Message[i, j];}}}}/**/////////////////////////////////////////////////////////////////// <summary>/// 输入一个链表,计算出其对应的总路径/// </summary>/// <param name="closed_list"></param>/// <returns></returns>public double Get_Weight(Queue <int> closed_list){lock (this){double sum = 0;int[] temp_Array = new int[closed_list.Count];temp_Array = closed_list.ToArray();for (int i = 0; i < Convert.ToInt32(temp_Array.Length) - 1; i++){sum = sum + City[temp_Array[i], temp_Array[i + 1]];}sum = sum + City[temp_Array[temp_Array.Length - 1], temp_Array[0]];return sum;}}/**////////////////////////////////////////////////////////////////// <summary>/// 产生到i城市后,下一个可走城市的集合。

蚁群算法——精选推荐

蚁群算法——精选推荐

蚁群算法⼀、蚁群算法简介 蚁群算法(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取值过⼤时,容易影响随机性和全局最优性;反之,收敛速度降低总结:蚁群算法对于参数的敏感程度较⾼,参数设置的好,算法的结果也就好,参数设置的不好则运⾏结果也就不好,所以通常得到的只是局部最优解。

蚁群算法求解最小点覆盖问题

蚁群算法求解最小点覆盖问题

蚁群算法求解最小点覆盖问题蚁群算法求解最小点覆盖问题蚁群算法是一种基于自然界中蚂蚁觅食行为的启发式搜索算法,其基本原理是通过模拟蚂蚁的觅食路径选择行为,从而找到问题的最优解。

最小点覆盖问题是计算机科学中的一个重要问题,其目标是找到能够覆盖所有边的最小点集合。

在蚁群算法中,一群蚂蚁以随机的方式在问题空间中搜索解空间。

在最小点覆盖问题中,解空间由所有可能的点集合组成。

每只蚂蚁通过释放信息素的方式与其他蚂蚁进行信息交流,并根据信息素的浓度选择下一个点。

蚂蚁在搜索空间中的移动行为可以用概率模型来表示。

每只蚂蚁在选择下一个点时,会根据该点的信息素浓度和启发式函数的值计算出一个概率,概率越大,选择该点的可能性就越高。

启发式函数可以根据问题的特性进行设计,以引导蚂蚁向着更有可能获得更优解的方向移动。

当蚂蚁选择好下一个点后,会在当前选择的点上释放一定量的信息素。

信息素的释放量取决于该点是否能够覆盖边,如果能够覆盖,则释放的信息素量更大;反之,则释放的信息素量较小。

通过这种方式,好的解对应的点将会得到更多的信息素,从而引导其他蚂蚁更有可能选择该点。

在蚁群算法中,信息素的更新和蒸发也是一个重要的步骤。

信息素的更新根据蚂蚁选择的路径以及路径的覆盖情况来进行,覆盖边多的路径将会释放更多的信息素。

而信息素的蒸发则是为了防止信息素过度积累,通过蒸发可以降低信息素浓度,使得蚂蚁在搜索空间中具有更好的探索能力。

通过多轮的迭代搜索,蚂蚁群体会逐渐收敛到最优解。

每次迭代结束后,根据蚂蚁选择的路径对问题进行评估,选择具有最小点数的解作为当前的最优解。

并且根据当前的最优解来更新全局最优解。

这个过程一直持续到满足停止条件为止。

蚁群算法作为一种启发式搜索算法,具有自适应性和自学习的优势。

它能够通过信息素的引导来全局搜索解空间,并在搜索过程中不断调整搜索策略,逐渐找到更优的解。

同时,在处理最小点覆盖问题时,蚁群算法还可以考虑到局部信息和全局信息的平衡,以及避免过早陷入局部最优解。

蚁群算法——精选推荐

蚁群算法——精选推荐

蚁群算法蚁群算法⽬录1 蚁群算法基本思想 (1)1.1蚁群算法简介 (1)1.2蚁群⾏为分析 (1)1.3蚁群算法解决优化问题的基本思想 (2)1.4蚁群算法的特点 (2)2 蚁群算法解决TSP问题 (3)2.1关于TSP (3)2.2蚁群算法解决TSP问题基本原理 (3)2.3蚁群算法解决TSP问题基本步骤 (5)3 案例 (6)3.1问题描述 (6)3.2解题思路及步骤 (6)3.3MATLB程序实现 (7)3.1.1 清空环境 (7)3.2.2 导⼊数据 (7)3.3.3 计算城市间相互距离 (7)3.3.4 初始化参数 (7)3.3.5 迭代寻找最佳路径 (7)3.3.6 结果显⽰ (7)3.3.7 绘图 (7)1 蚁群算法基本思想1.1 蚁群算法简介蚁群算法(ant colony algrothrim,ACA)是由意⼤利学者多⾥⼽(Dorigo M)、马聂佐(Maniezzo V )等⼈于20世纪90初从⽣物进化的机制中受到启发,通过模拟⾃然界蚂蚁搜索路径的⾏为,提出来的⼀种新型的模拟进化算法。

该算法⽤蚁群在搜索⾷物源的过程中所体现出来的寻优能⼒来解决⼀些系统优化中的困难问题,其算法的基本思想是模仿蚂蚁依赖信息素,通过蚂蚁间正反馈的⽅法来引导每个蚂蚁的⾏动。

蚁群算法能够被⽤于解决⼤多数优化问题或者能够转化为优化求解的问题,现在其应⽤领域已扩展到多⽬标优化、数据分类、数据聚类、模式识别、电信QoS管理、⽣物系统建模、流程规划、信号处理、机器⼈控制、决策⽀持以及仿真和系统辩识等⽅⾯。

蚁群算法是群智能理论研究领域的⼀种主要算法。

1.2 蚁群⾏为分析Bm=20t=0 m=10m=10t=11.3 蚁群算法解决优化问题的基本思想⽤蚂蚁的⾏⾛路径表⽰待优化问题的可⾏解,整个蚂蚁群体的所有路径构成待优化问题的解空间。

路径较短的蚂蚁释放的信息量较多,随着时间的推进,较短路径上积累的信息浓度逐渐增⾼,选择该路径的蚂蚁个数愈来愈多。

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

蚁群算法(C语言实现)/s/blog_6bb1b4b001016pt0.html\这是我2012年第一个学期的期末大作业。

不得不说这段代码参考了网络上的一些代码,以及书本上的一些相关数据。

但是无论是网络上还是书上难免总是有很多C++的影子,这是我自己理解之后用C编写的蚁群算法的代码。

这几个城市的相关测试数据在CSDN上可以找到。

//蚁群算法关于简单的TSP问题求解//#include<stdio.h>#include<stdlib.h>#include<string.h>#include<math.h>#include<time.h>#define M 13 //蚂蚁的数量#define N 144 //城市的数量#define R 1000 //迭代次数#define IN 1 //初始化的信息素的量#define MAX 0x7fffffff //定义最大值struct coordinate{char city[15]; //城市名int x; //城市相对横坐标int y; //城市相对纵坐标}coords[N];double graph[N][N]; //储存城市之间的距离的邻接矩阵,自己到自己记作MAX double phe[N][N]; //每条路径上的信息素的量double add[N][N]; //代表相应路径上的信息素的增量double yita[N][N]; //启发函数,yita[i][j]=1/graph[i][j]int vis[M][N]; //标记已经走过的城市int map[M][N]; //map[K][N]记录第K只蚂蚁走的路线double solution[M]; //记录某次循环中每只蚂蚁走的路线的距离int bestway[N]; //记录最近的那条路线double bestsolution=MAX;int NcMax; //代表迭代次数,理论上迭代次数越多所求的解更接近最优解,最具有说服力double alpha,betra,rou,Q;void Initialize(); //信息初始化void Inputcoords(FILE *fp); //将文件中的坐标信息读入void GreateGraph(); //根据坐标信息建图double Distance(int *p); //计算蚂蚁所走的路线的总长度void Result(); //将结果保存到out.txt中void Initialize(){alpha=2; betra=2; rou=0.7; Q=5000;NcMax=R;return ;}void Inputcoords(FILE *fp){int i;int number;if(fp==NULL){printf("Sorry,the file is not exist\n");exit(1);}else{for(i=0; i<N; ++i){fscanf(fp,"%d%s",&number,coords[i].city); fscanf(fp,"%d,%d",&coords[i].x,&coords[i].y); }}}void GreateGraph( ){int i,j;double d;for(i=0; i<N-1; ++i){graph[i][i]=MAX; //自己到自己标记为无穷大for(j=i+1; j<N; ++j){d=(double)((coords[i].x-coords[j].x)*(coords[i].x-coords[j].x)+(coords[i].y-coo rds[j].y)*(coords[i].y-coords[j].y));graph[j][i]=graph[i][j]=sqrt(d);}}graph[N-1][N-1]=MAX;return ;}double Distance(int *p){double d=0;int i;for(i=0; i<N-1; ++i)d+=graph[*(p+i)][*(p+i+1)];}d+=graph[*(p+i)][*(p)];return d;}void Result(){FILE *fl;int i;fl = fopen("out.txt","a"); //将结果保存在out.txt这个文件里面fprintf(fl,"%s\n","本次算法中的各参数如下:");fprintf(fl,"alpha=%.3lf, betra=%.3lf, rou=%.3lf, Q=%.3lf\n",alpha,betra,rou,Q); fprintf(fl,"%s %d\n","本次算法迭代次数为:",NcMax);fprintf(fl,"%s %.4lf\n","本算法得出的最短路径长度为:",bestsolution);fprintf(fl,"%s\n","本算法求得的最短路径为:");for(i=0; i<N; ++i)fprintf(fl,"%s → ",coords[bestway[i]].city);fprintf(fl,"%s",coords[bestway[0]].city);fprintf(fl,"\n\n\n");fclose(fl);return ;int main(){int NC=0;int i,j,k;int s;double drand,pro,psum;FILE *fp;Initialize();fp = fopen("coords.txt","r+");Inputcoords(fp);GreateGraph();fclose(fp);for(i=0; i<N; ++i){for(j=0; j<N; ++j){phe[i][j]=IN; //信息素初始化if(i!=j)yita[i][j]=100.0/graph[i][j]; //期望值,与距离成反比}}memset(map,-1,sizeof(map)); //把蚂蚁走的路线置空memset(vis,0,sizeof(vis)); //0表示未访问,1表示已访问srand(time(NULL));while(NC++<=NcMax){for(k=0; k<M; ++k){map[k][0]=(k+NC)%N; //给每只蚂蚁分配一个起点,并且保证起点在N个城市里 vis[k][map[k][0]]=1; //将起点标记为已经访问}s=1;while(s<N){for(k=0; k<M; ++k){psum=0;for(j=0; j<N; ++j){if(vis[k][j]==0){psum+=pow(phe[map[k][s-1]][j],alpha)*pow(yita[map[k][s-1]][j],betra); }}drand=(double)(rand()P00);drand/=5000.0; //生成一个小于1的随机数pro=0;for(j=0; j<N; ++j){if(vis[k][j]==0)pro+=pow(phe[map[k][s-1]][j],alpha)*pow(yita[map[k][s-1]][j],betra)/psum; if(pro>drand)break;}vis[k][j]=1; //将走过的城市标记起来map[k][s]=j; //记录城市的顺序}s++;}memset(add,0,sizeof(add));for(k=0; k<M; ++k) //计算本次中的最短路径//{solution[k]=Distance(map[k]); //蚂蚁k所走的路线的总长度if(solution[k]<bestsolution){bestsolution=solution[k];for(i=0; i<N; ++i)bestway[i]=map[k][i];}}for(k=0; k<M; ++k){for(j=0; j<N-1; ++j){add[map[k][j]][map[k][j+1]]+=Q/solution[k];}add[N-1][0]+=Q/solution[k];}for(i=0; i<N; ++i){for(j=0; j<N; ++j){phe[i][j]=phe[i][j]*rou+add[i][j];if(phe[i][j]<0.0001) //设立一个下界phe[i][j]=0.0001;else if(phe[i][j]>20) //设立一个上界,防止启发因子的作用被淹没phe[i][j]=20;}}memset(vis,0,sizeof(vis));memset(map,-1,sizeof(map));}Result();printf("Result is saved in out.txt\n"); return 0;}。

相关文档
最新文档