基于蚁群优化算法的TSP问题求解（ACO：Ant Colony Optimization）-CSDN博客

本文链接：https://blog.csdn.net/qq_44807756/article/details/144881363

⚠申明：未经许可，禁止以任何形式转载，若要引用，请标注链接地址。全文共计3077字，阅读大概需要10分钟
🌈更多学习内容，欢迎👏关注👀【文末】我的个人微信公众号：不懂开发的程序猿

❗❗❗知识付费，🈲止白嫖，有需要请后台私信或【文末】个人微信公众号联系我

基于蚁群优化算法的TSP问题求解（ACO：Ant Colony Optimization）

1. 蚁群优化算法理论研究现状
2. 蚁群优化算法的基本原理
3. 基于蚁群优化算法的TSP问题求解
4. 融合粒子群的改进蚁群优化算法的TSP求解（ACO_PSO）

1. 蚁群优化算法理论研究现状

最初提出的蚁群优化算法有三种版本：Ant density、Ant quantity和Ant cycle。在Ant density和Ant quantity中蚂蚁在两个位置节点间每移动一次后即更新信息素，而在Ant cycle中当所有的蚂蚁都完成了自己的行程后才对信息素进行更新，而且每只蚂蚁所释放的信息素被表达为反映相应行程质量的函数。
通过与其他各种通用的启发式算法相比，在不大于75城市的TSP中，这三种基本算法的求解能力还是比较理想的，但是当问题规模扩展时，AS的解题能力大幅度下降，因此，其后的ACO研究工作主要集中在AS性能的改进方面。

较早的一种改进方法是精英策略（Elitist Strategy），其思想是在算法开始后，即对所有已发现的最好路径给予额外的增强，并将随后与之对应的行程记为Tgb（全局最有行程）。
当进行信息素更新时，对这些行程予以加权，同时将经过这些行程的蚂蚁记为“精英”，从而增大较好行程的选择机会。这种改进型算法能够以更快的速度获得更好的解，但是若选择的精英过多则算法会由于较早的收敛于局部次优解而导致搜索中的过早停滞。

2. 蚁群优化算法的基本原理

蚁群优化算法是一种新型的模拟进化算法，鉴于目前国内尚缺乏这一方面的研究，其研究刚刚开始，远未像遗传算法、模拟退火算法等算法那样行程系统的分析方法和坚实的数学基础，有许多问题有待进一步研究，如算法的收敛性、理论依据等更多细致的工作还有待于进一步展开。
单只蚂蚁的行为极其简单，但由这样的单个简单个体所组成的蚁群群体却表现出及其复杂的行为，如：在蚂蚁运动路径上突然出现障碍物时，蚂蚁能够很快重新找到最优路径。像蚂蚁这类群居昆虫，虽然没有视觉，却能找到由蚁穴到食物源的最短路径，究其原因，蚂蚁个体之间通过一种称之为信息素（pheromone）的物质进行信息传递，从而能相互协作，完成复杂的任务。蚂蚁之所以表现出复杂有序的行为，个体之间的信息交流和相互协作起着重要作用。
蚂蚁在运动过程中，能够在它所过的路径上留下该物质，并以此指导自己的运动方向。蚂蚁倾向于朝着该物质强度高的方向移动。因此，由大量蚂蚁组成的蚁群的集体行为便表现出一种信息正反馈现象：某一路径上走过的蚂蚁越多，则后者选择该路径的概率约大。蚂蚁个体之间就是通过这种信息的交流达到搜索实物的目的。这里，用一个形象化的图示来说明蚂蚁群体的路径搜索原理和机制。

假定障碍物的周围有两条道路可以从蚂蚁的巢穴到达食物源（如图所示）：Nest-ABD-Food和Nest-ACD-Food，分别具有长度4和6。蚂蚁在单位时间内可移动一个单位长度的距离。开始时所有道路上都未留有任何信息素。

在这里插入图片描述

旅行商问题的蚁群优化算法的基本步骤

在这里插入图片描述

3. 基于蚁群优化算法的TSP问题求解

% TSP的蚁群算法program
function y20_1
clc % 清屏
clear all; % 删除workplace变量
close all; % 关掉显示图形窗口

% 保留每次迭代的最优解
% 以max(t^a*d^(-b))为依据找最优路劲，与保留的最优路劲比较
x=[41,37,54,25,7,2,68,71,54,83,64,18,22,83,91,...
    25,24,58,71,74,87,18,13,82,62,58,45,41,44,4];
y=[94,84,67,62,64,99,58,44,62,69,60,54,60,46,38,...
    38,42,69,71,78,76,40,40,7,32,35,21,26,35,50];
n=30;% n表示城市数目
c=100;
q=10^(+6);
NC=50;
r=0.9;% r表示轨迹持久性
a=1.5;% a表示轨迹相对重要性
b=2;% b表示能见度相对重要性
m=30;% m表示蚂蚁数目
for i=1:n
    for j=1:n
        dij(i,j)=sqrt((x(i)-x(j))^2+(y(i)-y(j))^2);%距离
    end
end
for i=1:n
    dij(i,i)=0.01;
end

min10=10^5;
t=ones(n)*c;
for nc=1:NC 
    
    tabu=ones(m,n);%禁忌表
    tabu(:,1)=0;
    path=ones(m,n);
    for k=1:m
        for step=1:n-1
            ta=t.^a;
            tb=dij.^(-b);
            td=ta.*tb;
            pd=tabu(k,:).*td(path(k,step),:);
            pk=pd/sum(pd);%概率
            rk=rand;
            spk=0;
            j=1;
            while j<=n;
                if rk<spk+pk(j)
                    break;
                else 
                    spk=spk+pk(j);
                    j=j+1;
                end
            end
            tabu(k,j)=0;
            path(k,step+1)=j;
        end
    end
    
    dt=zeros(n);
    for i=1:m
        ltsp(i)=ca_tsp(n,path(i,:),dij);
        for k=1:n-1
            dt(path(i,k),path(i,k+1))=dt(path(i,k),path(i,k+1))+q/ltsp(i);
            dt(path(i,k+1),path(i,k))=dt(path(i,k),path(i,k+1));
        end
        dt(path(i,n),path(i,1))=dt(path(i,n),path(i,1));
        dt(path(i,1),path(i,n))=dt(path(i,n),path(i,1)); 
    end
    
    [min1,i]=min(ltsp);
    if min1<min10;
        min10=min1;
        c0=path(i,:);
    end
    
    t=r*t+dt;
end
%%
ta=t.^a;
tb=dij.^(-b);
td=ta.*tb;
k=3;
ts(1)=1;
td(:,1)=0;
[my,i]=max(td(1,:));
ts(2)=i;
td(:,i)=0;
while k<=n
    [my,i]=max(td(i,:));
    ts(k)=i;
    td(:,i)=0; 
    k=k+1;
end
ts;
ltsp0=ca_tsp(n,ts,dij);
if min10<ltsp0
    ts=c0;
    ltsp0=min10;
end
k=1;
while k<=n;
    x1(k)=x(ts(k));
    y1(k)=y(ts(k));
    k=k+1;
end
x1(n+1)=x1(1);
y1(n+1)=y1(1);
%绘制图形
figure(1),
plot(x,y,'o--');
grid on

figure(2),
line(x1,y1,'color','r','linewidth',2);
hold on
plot(x,y,'o--');
grid on
[x1',y1']
ltsp0
end

% ca_tsp.m
% 计算路径长度
function ltsp=ca_tsp(n,c,dij)
i=1;
ltsp=dij(c(n),c(1));
while i<n;
    ltsp=ltsp+dij(c(i),c(i+1));
    i=i+1;
end
end


ans =

    41    94
    37    84
    58    69
    54    67
    54    62
    64    60
    68    58
    71    71
    74    78
    87    76
    83    69
    58    35
    62    32
    71    44
    83    46
    91    38
    82     7
    45    21
    41    26
    44    35
    24    42
    25    38
    18    40
    13    40
     4    50
    18    54
    22    60
    25    62
     7    64
     2    99
    41    94


ltsp0 =

     4.455120989568360e+02

>>

在这里插入图片描述

4. 融合粒子群的改进蚁群优化算法的TSP求解（ACO_PSO）

蚁群算法利用了信息素进行传递信息，而粒子群优化算法利用了本身信息、个体极值信息和全局极值3个信息，来指导粒子下一步迭代位置。蚁群算法利用正反馈原理和某种启发式算法的有机结合，容易出现早熟现象以及陷入局部最优解。混合的思路是让蚂蚁也具有“粒子”的特性，首先蚂蚁按照蚁群算法，完成一次遍历后，再让蚂蚁根据局部最优解和全局最优解进行调整。
调整思路如下：对于旅行商问题，其当前的位置是基本路径，让当前解与个体极值和全局极值分别作交叉操作，产生的解为新的位置，再做变异操作。

在这里插入图片描述

% TSP的蚁群——粒子群算法program
function y20_2
clc % 清屏
clear all; % 删除workplace变量
close all; % 关掉显示图形窗口

% 保留每次迭代的最优解
% 以max(t^a*d^(-b))为依据找最优路劲，与保留的最优路劲比较
x=[41,37,54,25,7,2,68,71,54,83,64,18,22,83,91,...
    25,24,58,71,74,87,18,13,82,62,58,45,41,44,4];
y=[94,84,67,62,64,99,58,44,62,69,60,54,60,46,38,...
    38,42,69,71,78,76,40,40,7,32,35,21,26,35,50];
n=30;% n表示城市数目
c=100;
q=10^(+6);
NC=50;
r=0.9;% r表示轨迹持久性
a=1.5;% a表示轨迹相对重要性
b=2;% b表示能见度相对重要性
m=30;% m表示蚂蚁数目
for i=1:n
    for j=1:n
        dij(i,j)=sqrt((x(i)-x(j))^2+(y(i)-y(j))^2);%距离
    end
end
for i=1:n
    dij(i,i)=0.01;
end

min10=10^5;
t=ones(n)*c;
for i=1:100
    road(i,:)=randperm(n);
    ltspc(i)=ca_tsp(n,road(i,:),dij);
end

ltspsort=sort(ltspc);
l30=ltspsort(m);%选择m个初始解,m只蚂蚁
i1=0;
for i=1:100
    if ltspc(i)<=1300
        for k=1:n-1
            t(road(i,k),road(i,k+1))=t(road(i,k),road(i,k+1))+10;
            t(road(i,k+1),road(i,k))=t(road(i,k),road(i,k+1));
        end
        t(road(i,1),road(i,n))=t(road(i,1),road(i,n))+10;
        t(road(i,n),road(i,1))=t(road(i,1),road(i,n));    
        i1=i1+1;
        pcbest(i1,:)=road(i,:);%初始pcbest路径长度
        plbest(i1)=ltspc(i);%初始plbest，路径
    end
end

[glbest,j]=min(plbest);%初始glbest路径长度
gcbest=pcbest(j,:);%初始gcbest路径
for nc=1:NC 
    
    tabu=ones(m,n);%禁忌表
    tabu(:,1)=0;
    path=ones(m,n);
    for k=1:m
        for step=1:n-1
            ta=t.^a;
            tb=dij.^(-b);
            td=ta.*tb;
            pd=tabu(k,:).*td(path(k,step),:);
            pk=pd/sum(pd);%概率
            rk=rand;
            spk=0;
            j=1;
            while j<=n;
                if rk<spk+pk(j)
                    break;
                else 
                    spk=spk+pk(j);
                    j=j+1;
                end
            end
            tabu(k,j)=0;
            path(k,step+1)=j;
        end
    end
    
     for i=1:m
        ltsp(i)=ca_tsp(n,path(i,:),dij);
        %交叉操作
        % 四种交叉子程序分别为cross_tsp_a,cross_tsp_b,cross_tsp_c,cross_tsp_d
        path1(i,:)=cross_tsp_d(path(i,:),gcbest,n);
        path1(i,:)=cross_tsp_d(path1(i,:),pcbest(i,:),n);
        %变异操作
        %四种变异子程序分别为mutation_a,mutation_b,mutation_c,mutation_d
        path1(i,:)=mutation_d(path1(i,:),n);
        % 计算新路径长度之和
        ltsp1(i)=ca_tsp(n,path1(i,:),dij);
        %求个体极值
        if ltsp1(i)<ltsp(i)
            ltsp(i)=ltsp1(i);
            path(i,:)=path1(i,:);
        end
        if ltsp(i)<plbest(i)
            plbest(i)=ltsp(i);
            pcbest(i,:)=path(i,:);
        end
     end
     
     %找全局极值
     [glbest,j]=min(plbest);
     gcbest=pcbest(j,:);
     dt=zeros(n);
     for i=1:m
        for k=1:n-1
            dt(path(i,k),path(i,k+1))=dt(path(i,k),path(i,k+1))+q/ltsp(i);
            dt(path(i,k+1),path(i,k))=dt(path(i,k),path(i,k+1));
        end
        dt(path(i,n),path(i,1))=dt(path(i,n),path(i,1))+q/ltsp(i);
        dt(path(i,1),path(i,n))=dt(path(i,n),path(i,1)); 
    end
    t=r*t+dt;
end
%%
ta=t.^a;
tb=dij.^(-b);
td=ta.*tb;
k=3;
ts(1)=1;
td(:,1)=0;
[my,i]=max(td(1,:));
ts(2)=i;
td(:,i)=0;
while k<=n
    [my,i]=max(td(i,:));
    ts(k)=i;
    td(:,i)=0; 
    k=k+1;
end

ts;
ltsp0=ca_tsp(n,ts,dij);
if glbest<ltsp0
    ts=gcbest;
    ltsp0=glbest;
end

k=1;
while k<=n;
    x1(k)=x(ts(k));
    y1(k)=y(ts(k));
    k=k+1;
end

x1(n+1)=x1(1);
y1(n+1)=y1(1);
%绘制图形
figure(1),
plot(x,y,'o--');
grid on

figure(2),
line(x1,y1,'color','r','linewidth',2);
hold on
plot(x,y,'o--');
grid on
[x1',y1']
ltsp0
end

% ca_tsp.m
% 计算路径长度
function ltsp=ca_tsp(n,c,dij)
i=1;
ltsp=dij(c(n),c(1));
while i<n;
    ltsp=ltsp+dij(c(i),c(i+1));
    i=i+1;
end
end