VRPD问题基于蚁群算法求解运钞车运输问题VRPD

Posted 2021-06-24 MatlabQQ1575304183

 

蚁群算法的基本思想:

蚁群算法的基本原理:

1、蚂蚁在路径上释放信息素。

 

2、碰到还没走过的路口，就随机挑选一条路走。同时，释放与路径长度有关的信息素。

 

3、信息素浓度与路径长度成反比。后来的蚂蚁再次碰到该路口时，就选择信息素浓度较高路径。

 

4、最优路径上的信息素浓度越来越大。

 

5、最终蚁群找到最优寻食路径。

 

人工蚁群与真实蚁群对比:

 

基于TSP问题的基本蚁群算法：

 

TSP求解中，假设蚁群算法中的每只蚂蚁是具有以下特征的简单智能体：

每次周游，每只蚂蚁在其经过的支路（i,j）上都留下信息素。

‚蚂蚁选择城市的概率与城市之间的距离和当前连接支路上所包含的信息素余量有关。

ƒ为了强制蚂蚁进行合法的周游，直到一次周游完成后，才允许蚂蚁游走已访问过的城市（这可由禁忌表来控制）。

 

基本蚁群的两个过程:

(1)状态转移

(2)信息素更新

 

 

 

(1)状态转移

 

为了避免残留信息素过多而淹没启发信息，在每只蚂蚁走完一步或者完成对所有n个城市的遍历(也即一个循环结束)后，要对残留信息进行更新处理。

由此，t+n时刻在路径(i,j)上的信息量可按如下规则进行调整： 

 

 

 

(2)信息素更新模型

 

蚁周模型（Ant-Cycle模型）

蚁量模型（Ant-Quantity模型）

蚁密模型（Ant-Density模型）

 

区别：

1.蚁周模型利用的是全局信息，即蚂蚁完成一个循环后更新所有路径上的信息素；

2.蚁量和蚁密模型利用的是局部信息，即蚂蚁完成一步后更新路径上的信息素。

 

蚁群算法基本流程:

 

蚁群算法中主要参数的选择:

 

 

蚁群算法中主要参数的理想选择如下:

 

国内外，对于离散域蚁群算法的改进研究成果很多，例如自适应蚁群算法、基于信息素扩散的蚁群算法等，这里仅介绍离散域优化问题的自适应蚁群算法。

自适应蚁群算法：对蚁群算法的状态转移概率、信息素挥发因子、信息量等因素采用自适应调节策略为一种基本改进思路的蚁群算法。

自适应蚁群算法中两个最经典的方法：蚁群系统(AntColony System, ACS)和最大-最小蚁群系统(MAX-MINAnt System, MMAS)。

 

蚁群系统对基本蚁群算法改进:

 

①蚂蚁的状态转移规则不同；

②全局更新规则不同；

③新增了对各条路径信息量调整的局部更新规则

 

```python

%{

[代码说明]
蚁群算法解决VRP问题

[算法说明]
首先实现一个ant蚂蚁类，用此蚂蚁类实现搜索。
算法按照tsp问题去解决，但是在最后计算路径的时候有区别。

比如有10个银行网点,网点1是银行中心，蚂蚁搜索的得到的路径是1,3,5,9,4,10,2,6,8,7。

计算路径的时候把网点依次放入派送线路中,
每放入一个网点前，检查该网点放入后是否会超过运钞车最大载重
如果没有超过就放入
如果超过，就重新开始一条派送路线
……
直到最后一个网点运送完
就会得到多条派送路线


%}

%清除所有变量和类的定义
clear;
clear classes;

%蚁群算法参数(全局变量)
global ALPHA; %启发因子
global BETA; %期望因子
global ANT_COUNT;  %蚂蚁数量
global CITY_COUNT;  %网点数量
global RHO; %信息素残留系数!!!
global IT_COUNT; %迭代次数
global DAry; %两两网点间距离
global TAry; %两两网点间信息素
global CITYWAry; %网点货物需求量
global VW; %运钞车最大载重

%===================================================================

%设置参数变量值
ALPHA=1.0;
BETA=2.0;
RHO=0.95;

IT_COUNT=1000;

VW=100;

%===================================================================
%读取数据并根据读取的数据设置其他参数
load data.txt; %从文本文件加载数据
city_xy_ary=data(:,2:3); %得到网点的坐标数据
CITYWAry=data(:,4); %得到每个网点的资金需求量
x_label=data(:,2); %第二列为横坐标
y_label=data(:,3); %第三列为纵坐标
C=[x_label y_label];      %坐标矩阵

CITY_COUNT=length(CITYWAry); %得到网点数量(包括银行中心在内)
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_COUNT
    for j=1:CITY_COUNT       
       DAry(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);
    end
end


% 初始化网点间信息素
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; %一次搜索是否有更优解产生


L_best=zeros(IT_COUNT,1);
%开始搜索
for i=1:IT_COUNT    
        
    fprintf('开始第%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; 
        end        
      %L_best(i)=max(Length_Ary); 
    end
     L_best(i)=Best_Path_Length; 
    %有更好解产生,进行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_COUNT            
        
        m=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_COUNT
        for n=1:CITY_COUNT
            if (TAry(m,n)>Tmax) 
                TAry(m,n)=Tmax;
            end
            if (TAry(m,n)<Tmin)
                TAry(m,n)=Tmin;                
            end
        end
    end
    
    %-------------------------------------------------------------
    %换行
    fprintf('\\n');
       
end

tm2=datenum(clock); %记录算法结束执行时的时间

fprintf('\\n搜索完成 , 用时%.3f秒 , 最佳路径长为%.3f , 派送方案如下 :：\\n\\n[1]',(tm2-tm1)*86400,Best_Path_Length);


%===================================================================
%输出结果
dbW=0;
for i=2:CITY_COUNT
    m=Best_Path(i-1); %上一个网点
    n=Best_Path(i); %当前网点

    if (dbW+CITYWAry(n)>VW) %运送的资金超过限制
        fprintf('          (满载率 : %.1f%%)\\n[1]-%d',dbW*100/VW,n);
        dbW=CITYWAry(n);  %运输的资金等于该城市的需求量
    else %没有超过限制
        fprintf('-%d',n);
        dbW=dbW+CITYWAry(n); %运输的资金加上该城市的需求量                
    end                
end
fprintf('          (满载率 : %.1f%%)',dbW*100/VW);

fprintf('\\n\\n');

%====== [程序结束]=====================================================


figure(1)   %作迭代收敛曲线图
x=linspace(0,IT_COUNT,IT_COUNT);
y=L_best(:,1);
plot(x,y);
xlabel('迭代次数'); ylabel('最短路径长度');











```

完整代码或者仿真咨询添加QQ1575304183