精华内容
下载资源
问答
  • matlab版蚁群算法路径规划程序,用G2D算法
  • matlab版蚁群算法路径规划程序,用G2D算法
  • 蚁群算法路径规划蚁群算法路径规划蚁群算法路径规划
  • 蚁群算法路径规划,蚁群算法路径规划matlab代码,matlab源码
  • 蚁群算法路径规划

    2018-07-01 22:00:01
    matlab源码,通过蚁群算法实现路径规划,能够调参并很好的画图输出结果。
  • (MATLAB)针对栅格路径规划的蚁群算法,蚁群算法路径规划matlab代码,matlab源码
  • (MATLAB)针对栅格路径规划的蚁群算法,蚁群算法路径规划matlab代码,matlab源码.rar
  • 本代码主要利用MATLAB工具实现MATLAB——蚁群算法路径规划,简单明了,易于理解
  • 用MATLAB 实现,基于栅格地图的蚁群算法路径规划,含蚁群相关文档。
  • 针对栅格路径规划蚁群算法。本代码框架将会使你快速清楚蚁群算法基本原理。
  • 蚁群算法路径规划.rar

    2021-02-10 08:45:15
    蚁群算法根据模拟蚂蚁寻找食物的最短路径行为来设计的仿生算法,因此一般而言,蚁群算法用来解决最短路径问题,并真的在旅行商问题(TSP,一个寻找最短路径的问题)上取得了比较好的成效。目前,也已渐渐应用到其他...
  • 3维蚁群算法路径规划

    2015-04-22 18:27:55
    3维环境下蚁群算法路径规划方法及MATLAB代码实现
  • 我学习蚁群算法路径规划时,感觉比较非常有用的文档和matlab程序。 关于蚁群算法的参数设置研究.pdf 基于蚁群算法的机器人路径规划.pdf 蚁群算法在MATLAB中的实现.pdf 蚁群算法.m
  • 蚁群算法路径规划MATLAB栅格图实现

    千次阅读 多人点赞 2020-07-25 09:29:18
    蚁群算法路径规划 蚁群算法的基本原理: 1、蚂蚁在路径上释放信息素。 2、碰到还没走过的路口,就随机挑选一条路走。同时,释放与路径长度有关的信息素。 3、信息素浓度与路径长度成反比。后来的蚂蚁再次碰到该路口时...

    蚁群算法的基本原理:
    1、蚂蚁在路径上释放信息素。

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

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

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

    5、最终蚁群找到最优寻食路径。
    基于栅格图寻找最优路径的基本蚁群的两个过程:

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

    由此,t+n时刻在路径(i,j)上的信息量可按如下规则进行调整
    在这里插入图片描述
    (2)信息素更新
    1.主要参数
    在这里插入图片描述
    2.蚁群算法公式
    在这里插入图片描述
    3.更新规则
    在这里插入图片描述

    (3)代码如下

    clear all
    clc
    G=[ 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 
        0 0 1 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 
        0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 
        0 0 1 1 0 0 0 1 0 1 1 0 1 0 0 1 0 1 0 0 
        1 0 0 1 0 0 1 0 1 0 0 0 1 0 1 0 0 1 0 0 
        0 0 0 1 0 0 0 1 0 0 0 1 0 0 1 1 0 0 0 0 
        0 1 0 1 1 1 0 0 1 1 0 0 0 1 0 0 1 0 0 0 
        0 1 0 1 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 0 
        0 0 0 0 1 0 1 0 0 0 1 0 0 0 0 1 1 1 0 0 
        0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 
        0 0 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 
        0 0 0 1 0 1 0 0 0 0 1 0 1 0 0 0 0 0 0 0
        0 0 0 0 0 1 0 1 1 1 0 0 0 1 0 0 0 0 0 0
        0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0
        0 0 0 1 0 0 1 0 0 0 0 1 0 0 0 1 1 0 0 0
        0 0 0 0 0 1 0 0 0 0 1 0 0 1 0 0 0 1 1 0
        1 1 1 1 1 0 0 1 1 1 0 0 1 0 1 0 0 0 0 1
        0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 1 0 0
        0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 1 0 0
        0 0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0
        ];
     
      MM = size(G,1);
        figure(3)
        axis([0,MM,0,MM])
        for i=1:MM
            for j=1:MM
                if G(i,j)==1
                    x1=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.3,0.3,0.3]);
                    hold on
                else
                    x1=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 on
               end
            end
        end
     %把栅格地图转为邻接矩阵
    MM=size(G,1);%返回G的行数
    D=zeros(MM*MM,MM*MM);%N表示问题的规模(象素个数)返回矩阵D行数
    a=1;%小方格象素的边长
    % Ex=a*(mod(E,MM)-0.5);%终止点横坐标 a乘以变量E对MM(行)取余(得到列)后减0.5 即所处列
    % if Ex==-0.5
    %     Ex=MM-0.5;
    % end
    % Ey=a*(MM+0.5-ceil(E/MM));%E/MM结果取整 终止点纵坐标
    % Eta=zeros(1,N);%启发式信息,取为至目标点的直线距离的倒数 初始信息素矩阵
    for i= 1:MM
       for j=1:MM 
           if G(i,j)==0
               for m=1:MM
                   for n=1:MM
                       if G(m,n)==0
                           im=abs(i-m);
                           jn=abs(j-n);
                           if(im+jn==1)||(im==1&&jn==1)
                               D((i-1)*MM+j,(m-1)*MM+n)=(im+jn)^0.5;
                           end                       
                       end
                   end
               end
           end
       end
    end
    for i= 1:MM
       for j=1:MM 
           if G(i,j)==1
               for m=1:MM
                   for n=1:MM
                       if G(m,n)==1
                           im=abs(i-m);
                           jn=abs(j-n);
                           if(im==1&&jn==1)
                               if j>n
                                   if i>m
                                   D((i-2)*MM+j,(i-1)*MM+j-1)=0;  %YY=(i-2)*MM+j;
                                   end
                                   if i<m
                                    D(i*MM+j,(i-1)*MM+j-1)=0; %YY=i*MM+j;
                                   end
                                         %%XX=(i-1)*MM+j-1;
                               end
                               if j<n
                                   %XX=(i-1)*MM+j+1;
                                   if i>m
                                   D((i-2)*MM+j,(i-1)*MM+j+1)=0;  %YY=(i-2)*MM+j;
                                   end
                                   if i<m
                                    D(i*MM+j,(i-1)*MM+j+1)=0; %YY=i*MM+j;
                                   end
                               end
                               
                           end                       
                       end
                   end
               end
           end
       end
    end
    N=size(D,1);
    %下面构造启发式信息矩阵
    Eta=zeros(1,N);%启发式信息,取为至目标点的直线距离的倒数 初始信息素矩阵
    for i=1:MM
        for j=1:MM
            Eta(1,(i-1)*MM+j)=((MM-i)^2+(MM-j)^2)^0.5;      
        end
    end
    Eta(1,MM*MM)=0.01;
    K=100;
    S=1;
    M=50;
    p = 2 ;
    Alpha= 1.5 ;                       %% Alpha表征信息素重要程度的参数
    Beta = 6 ;                          % %  Beta表征启发式因子重要程度的参数
    Rho = 0.2;  % Rho信息素蒸发系数
    sim= 0.3 ;     %西格玛
    Q = 1 ;                               % Q信息素增加强度系数
    minkl = inf ;
    minkm = inf ;
    N=size(D,1);
    minl = 0 ;
    Tau=ones(N,N);%信息素
    ROUTES=cell(K,M);%用细胞结构存储每一代的每一只蚂蚁的爬行路线 蚂蚁个数*迭代次数矩阵,每个元素是一个结构
    PL=zeros(K,M);%用矩阵存储每一代的每一只蚂蚁的爬行路线长度
    %% -----------启动K轮蚂蚁觅食活动,每轮派出M只蚂蚁--------------------
    tic
    for k=1:K
        %disp(k);
        for m=1:M
    %%     第一步:状态初始化
            W=S;%当前节点初始化为起始点
            Path=S;%爬行路线初始化
            pathlength=0;%爬行路线长度初始化
            Tabu=ones(1,N); %生成禁忌列表,所有节点均未走过,所以都置为1
            Tabu(S)=0;%已经在初始点了,因此要排除
            DD=D;%邻接矩阵初始化
    %%     第二步:下一步可以前往的节点
            DW=DD(W,:);
            LJD=find(DW>0);%可选节点集 即返回可以走的节点坐标<矩阵编号>
            Len_LJD=length(LJD);%计数 可选节点的个数 
    %%     觅食停止条件:蚂蚁未遇到食物或者陷入死胡同
            while Len_LJD>=1&&W~=N  %W~=E&&
    %%         第三步:转轮赌法选择下一步怎么走
                node=zeros(1,Len_LJD); %遍历可选节点
                for i=1:Len_LJD
                     node(i)=(Tau(W,LJD(i))^Alpha)*((1/Eta(1,LJD(i)))^Beta); %w行i个节点
                end
                node=node/(sum(node));%建立概率分布 把各个路径的概率统一到和为1;
                Pcum=cumsum(node);  %node累计值 
                Select=find(Pcum>=rand);%产生任意0~1之间的随机数,轮盘赌算法,尽量避免陷入局部最优解
                to_visit=LJD(Select(1));%下一步将要前往的节点
    %%         第四步:状态更新和记录
                Path=[Path,to_visit];%路线节点增加
                pathlength=pathlength+DD(W,to_visit);%路径长度增加,记录本次迭代最佳路线长度,每只蚂蚁都有自己走过的长度记录在向量中。
                W=to_visit;%蚂蚁移到下一个节点
                %N:所有点
                for n=1:N
                    if Tabu(n)==0    %禁忌列表
                        DD(W,n)=0;  %在此次循环中设置为不可达   
                        DD(n,n)=0;
                    end
                end
                Tabu(W)=0;%已访问过的节点从禁忌表中删除
                DW=DD(W,:);
                LJD=find(DW>0);%可选节点集
                Len_LJD=length(LJD);%可选节点的个数
            end
    %%     第五步:记下每一代每一只蚂蚁的觅食路线和路线长度
            ROUTES{k,m}=Path; %第k次迭代 第m只蚂蚁的路线
            if Path(end)==N
                PL(k,m)=pathlength; %到达目标点的路线长度
            else
                PL(k,m)=inf;  %进入死胡同
            end
        end
    %% 第六步:更新信息素
        Delta_Tau=zeros(N,N);%更新量初始化
        for mm=1:M %M只蚂蚁
            if PL(k,mm)<inf %顺利到达目标点的蚂蚁路线长度
                ROUT=ROUTES{k,mm}; %具体路线
                TS=length(ROUT)-1; %跳数 蚂蚁转移次数
                PL_km=PL(k,mm);%路线长度
                for s=1:TS
                    x=ROUT(s); %上一个节点
                    y=ROUT(s+1); %下一个节点
                    Delta_Tau(x,y)=Delta_Tau(x,y)+Q/PL_km; %(x,y)即两个节点之间的关系(信息素量) 系数除以路线长度
                    Delta_Tau(y,x)=Delta_Tau(y,x)+Q/PL_km;
                end
            end
        end
        Tau=(1-Rho).*Tau+Delta_Tau;%信息素挥发一部分,新增加一部分
    end
    toc
    %% ---------------------------绘图--------------------------------
    figure(4)
    axis([0,K,0,20])
    for i=1:K
       ggb=PL(i,:);
       mmmda(i)=sum(ggb)/50;
    end
    plot(mmmda)
    plotif=1; %是否绘图的控制参数
    if plotif==1
        %绘收敛曲线
       
        meanPL=zeros(1,K); %k:迭代次数
        minPL=zeros(1,K);
        for i=1:K
            PLK=PL(i,:); %将第i次迭代爬行路线长度赋值给PLK
            Nonzero=find(PLK<inf);%返回一系列可行路线的编号
            if length(Nonzero)~=0
                PLKPLK=PLK(Nonzero);%留下可行路线,重新排列
                meanPL(i)=mean(PLKPLK); %求取这次可行路径的平均值
                minPL(i)=min(PLKPLK);%提出最小路径
            end
        end
    end
    
    plotif3=1;%绘最短蚂蚁爬行图
    if plotif3==1
        figure(2)
        axis([0,MM,0,MM])
        for i=1:MM
            for j=1:MM
                if G(i,j)==1
                    x1=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 on
                else
                    x1=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 on
                end
            end
        end
        minmumPLK=inf;
        for k=1:K
            PLK=PL(k,:); %将第k次迭代爬行路线长度赋值给PLK
            minPLK=min(PLK);
            if(minPLK<minmumPLK)
            pos=find(PLK==minPLK); %找到与最短爬行路线长度相等的路径标号
            minmumPLK=minPLK;
            minm=pos(1);
            mink=k ; %迭代k次
            end
        end
            ROUT=ROUTES{mink,minm}; %找出最小路径路线
            LENROUT=length(ROUT);
            Rx=ROUT;
            Ry=ROUT;
        for ii=1:LENROUT
                Rx(ii)=a*(mod(ROUT(ii),MM)-0.5);
                if Rx(ii)==-0.5
                    Rx(ii)=MM-0.5;
                end
                Ry(ii)=a*(MM+0.5-ceil(ROUT(ii)/MM));
         end
            plot(Rx,Ry)
            hold on
    end
    
    
    
    

    欢迎使用Markdown编辑器

    你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解一下Markdown的基本语法知识。

    新的改变

    我们对Markdown编辑器进行了一些功能拓展与语法支持,除了标准的Markdown编辑器功能,我们增加了如下几点新功能,帮助你用它写博客:

    1. 全新的界面设计 ,将会带来全新的写作体验;
    2. 在创作中心设置你喜爱的代码高亮样式,Markdown 将代码片显示选择的高亮样式 进行展示;
    3. 增加了 图片拖拽 功能,你可以将本地的图片直接拖拽到编辑区域直接展示;
    4. 全新的 KaTeX数学公式 语法;
    5. 增加了支持甘特图的mermaid语法1 功能;
    6. 增加了 多屏幕编辑 Markdown文章功能;
    7. 增加了 焦点写作模式、预览模式、简洁写作模式、左右区域同步滚轮设置 等功能,功能按钮位于编辑区域与预览区域中间;
    8. 增加了 检查列表 功能。

    功能快捷键

    撤销:Ctrl/Command + Z
    重做:Ctrl/Command + Y
    加粗:Ctrl/Command + B
    斜体:Ctrl/Command + I
    标题:Ctrl/Command + Shift + H
    无序列表:Ctrl/Command + Shift + U
    有序列表:Ctrl/Command + Shift + O
    检查列表:Ctrl/Command + Shift + C
    插入代码:Ctrl/Command + Shift + K
    插入链接:Ctrl/Command + Shift + L
    插入图片:Ctrl/Command + Shift + G
    查找:Ctrl/Command + F
    替换:Ctrl/Command + G

    合理的创建标题,有助于目录的生成

    直接输入1次#,并按下space后,将生成1级标题。
    输入2次#,并按下space后,将生成2级标题。
    以此类推,我们支持6级标题。有助于使用TOC语法后生成一个完美的目录。

    如何改变文本的样式

    强调文本 强调文本

    加粗文本 加粗文本

    标记文本

    删除文本

    引用文本

    H2O is是液体。

    210 运算结果是 1024.

    插入链接与图片

    链接: link.

    图片: Alt

    带尺寸的图片: Alt

    居中的图片: Alt

    居中并且带尺寸的图片: Alt

    当然,我们为了让用户更加便捷,我们增加了图片拖拽功能。

    如何插入一段漂亮的代码片

    博客设置页面,选择一款你喜欢的代码片高亮样式,下面展示同样高亮的 代码片.

    // An highlighted block
    var foo = 'bar';
    

    生成一个适合你的列表

    • 项目
      • 项目
        • 项目
    1. 项目1
    2. 项目2
    3. 项目3
    • 计划任务
    • 完成任务

    创建一个表格

    一个简单的表格是这么创建的:

    项目Value
    电脑$1600
    手机$12
    导管$1

    设定内容居中、居左、居右

    使用:---------:居中
    使用:----------居左
    使用----------:居右

    第一列第二列第三列
    第一列文本居中第二列文本居右第三列文本居左

    SmartyPants

    SmartyPants将ASCII标点字符转换为“智能”印刷标点HTML实体。例如:

    TYPEASCIIHTML
    Single backticks'Isn't this fun?'‘Isn’t this fun?’
    Quotes"Isn't this fun?"“Isn’t this fun?”
    Dashes-- is en-dash, --- is em-dash– is en-dash, — is em-dash

    创建一个自定义列表

    Markdown
    Text-to- HTML conversion tool
    Authors
    John
    Luke

    如何创建一个注脚

    一个具有注脚的文本。2

    注释也是必不可少的

    Markdown将文本转换为 HTML

    KaTeX数学公式

    您可以使用渲染LaTeX数学表达式 KaTeX:

    Gamma公式展示 Γ ( n ) = ( n − 1 ) ! ∀ n ∈ N \Gamma(n) = (n-1)!\quad\forall n\in\mathbb N Γ(n)=(n1)!nN 是通过欧拉积分

    Γ ( z ) = ∫ 0 ∞ t z − 1 e − t d t   . \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}dt\,. Γ(z)=0tz1etdt.

    你可以找到更多关于的信息 LaTeX 数学表达式here.

    新的甘特图功能,丰富你的文章

    Mon 06 Mon 13 Mon 20 已完成 进行中 计划一 计划二 现有任务 Adding GANTT diagram functionality to mermaid
    • 关于 甘特图 语法,参考 这儿,

    UML 图表

    可以使用UML图表进行渲染。 Mermaid. 例如下面产生的一个序列图:

    张三 李四 王五 你好!李四, 最近怎么样? 你最近怎么样,王五? 我很好,谢谢! 我很好,谢谢! 李四想了很长时间, 文字太长了 不适合放在一行. 打量着王五... 很好... 王五, 你怎么样? 张三 李四 王五

    这将产生一个流程图。:

    链接
    长方形
    圆角长方形
    菱形
    • 关于 Mermaid 语法,参考 这儿,

    FLowchart流程图

    我们依旧会支持flowchart的流程图:

    Created with Raphaël 2.2.0 开始 我的操作 确认? 结束 yes no
    • 关于 Flowchart流程图 语法,参考 这儿.

    导出与导入

    导出

    如果你想尝试使用此编辑器, 你可以在此篇文章任意编辑。当你完成了一篇文章的写作, 在上方工具栏找到 文章导出 ,生成一个.md文件或者.html文件进行本地保存。

    导入

    如果你想加载一篇你写过的.md文件,在上方工具栏可以选择导入功能进行对应扩展名的文件导入,
    继续你的创作。


    1. mermaid语法说明 ↩︎

    2. 注脚的解释 ↩︎

    展开全文
  • 使用蚁群算法进行智能避障,并且不断比较出路程,然后寻找出最短路径。此代码有所优化。使用蚁群算法进行智能避障,并且不断比较出路程,然后寻找出最短路径。此代码有所优化。
  • 蚁群算法路径规划TSP

    千次阅读 2020-01-16 13:55:46
     若干年前读研的时候,学院有一个教授,专门做群蚁算法的,很厉害,偶尔了解了一点点。感觉也是生物智能的一个体现,和遗传算法、神经网络有异曲同工之妙。只不过当时没有实际需求学习,所以没去研究。最近有一个...

    阅读目录

      若干年前读研的时候,学院有一个教授,专门做群蚁算法的,很厉害,偶尔了解了一点点。感觉也是生物智能的一个体现,和遗传算法、神经网络有异曲同工之妙。只不过当时没有实际需求学习,所以没去研究。最近有一个这样的任务,所以就好好把基础研究了一下,驱动式学习,目标明确,所以还是比较快去接受和理解,然后写代码实现就好了。今天就带领大家走近TSP问题以及群蚁算法。 

    机器学习目录:【目录】数据挖掘与机器学习相关算法文章总目录

    本文原文地址:群蚁算法理论与实践全攻略——旅行商等路径优化问题的新方法 

    回到目录

    1.关于旅行商(TSP)问题及衍化

      旅行商问题(Traveling Saleman Problem,TSP)是车辆路径调度问题(VRP)的特例,由于数学家已证明TSP问题是NP难题,因此,VRP也属于NP难题。旅行商问题(TSP)又译为旅行推销员问题、货郎担问题,简称为TSP问题,是最基本的路线问题,该问题是在寻求单一旅行者由起点出发,通过所有给定的需求点之后,最后再回到原点的最小路径成本。——旅行商问题百科

      很明显,当节点数很少时,大多数人都会想到,问题很简单,直接穷举就OK了,但实际问题中,节点数往往很大,变得不可能。例如:对于一个仅有16个城市的旅行商问题,如果用穷举法来求问题的最优解,需比较的可行解有:15!/2=653,837,184,000个。在1993年,使用当时的工作站用穷举法求解此问题需时92小时。即使现在计算机速度快,但是面对复杂的问题,仍然不够。这就是所谓的“组合爆炸”,指数级的增长,所以科学家逐步寻找近似算法或者启发式算法,目的是在合理的时间范围内找到可接受的最优解。

      TSP问题解决算法的发展可以分为3个部分:

    1).经典精确算法:穷举法、线性规划算法、动态规划算法、分支定界算法等运筹学中的传统算法,这些算法复杂度一般都很大,只适用于求解小规模问题。

    2).近似算法:当问题规模较大时,其所需的时间成级数增长,这是我们无法接受的,算法求解问题的规模受到了很大的限制,一个很自然的想法就是牺牲精确解法中的最优性,去寻找一个好的时间复杂度我们可以容忍的,同时解的质量我们可以接受的算法.基于这一思想所设计出的算法统称为近似算法。如插入算法,最邻近算法等。

    3).智能算法:随着科学技术和生产的不断发展,许多实际问题不可能在合理的时间范围内找到全局最优解,这就促使了近代最优化问题求解方法的产生。随着各种不同搜索机制的启发式算法相继出现,如禁忌搜索、遗传算法、模拟退火算法、人工神经网络、进化策略、进化编程、粒子群优化算法、蚁群优化算法和免疫计算等,掀起了研究启发式算法的高潮。

      具体每一种算法不再详细描述,大家可以针对性的寻找相应资料进行了解。

      TSP问题在实际的生产生活中,更加实际环境不同,有很多衍生的经典问题。车辆路径调度(VRP)扩展问题是经典VRP加入各种约束条件后而形成的。例如需求约束形成的需求随机的车辆路径问题(SVRP);加入时间约束得到的带时间窗的车辆路径题(VRPTW);加入距离约束的距离约束车辆路径问题(DVRP);根据其它条件的不同,还有多配送中心车辆路径问题(MDVRP)、可切分的车辆路径问题(SDVRP);先配送再收集车辆路径问题(VRPB)、配送收集车辆路径问题(VRPPD);信息不完全的模糊车辆路径问题(FVRP)[3]。

    回到目录

    2.群蚁算法基本原理

    2.1 算法综述

      对于VRP问题,求解算法大致可分为精确算法和人工智能算法两大类。精确性算法基于严格的数学手段,在可以求解的情况下,解的质量较好。但是由于算法严格,运算量大,特别是大规模的问题几乎无法求解。所以其应用只能是小规模的确定性问题,面对中小规模问题,人工智能算法在精度上不占优势。但规模变大时,人工智能方法基本能在可接受时间里,找到可接受的满意解,这是精确算法难以做到的。由于的实际问题,各种约束错综复杂,人工智能算法显示出了巨大的优越性,也正因为如此,实际应用中,人工智能算法要更广泛。求解车辆路径调度问题的精确算法有动态规划法、分枝定界法等。并开始寻求所得结果可接受的启发式算法,以处理大规模实际问题,一些其他学科的新一代优化算法相继出现,如禁忌搜索算法,遗传算法,人工神经网络算法,以及现在研究较多的蚁群算法等。

    2.2 群蚁算法的原理

      蚁群算法是受到对真实蚂蚁群觅食行为研究的启发而提出。生物学研究表明:一群相互协作的蚂蚁能够找到食物和巢穴之间的最短路径,而单只蚂蚁则不能。生物学家经过大量细致观察研究发现,蚂蚁个体之间的行为是相互作用相互影响的。蚂蚁在运动过程中,能够在它所经过的路径上留下一种称之为信息素的物质,而此物质恰恰是蚂蚁个体之间信息传递交流的载体。蚂蚁在运动时能够感知这种物质,并且习惯于追踪此物质爬行,当然爬行过程中还会释放信息素。一条路上的信息素踪迹越浓,其它蚂蚁将以越高的概率跟随爬行此路径,从而该路径上的信息素踪迹会被加强,因此,由大量蚂蚁组成的蚁群的集体行为便表现出一种信息正反馈现象。某一路径上走过的蚂蚁越多,则后来者选择该路径的可能性就越大。蚂蚁个体之间就是通过这种间接的通信机制实现协同搜索最短路径的目标的。我们举例简单说明蚂蚁觅食行为:

        

        如上图a,b,c的示意图:

        a图是原始状态,蚂蚁起始点为A,要到达E,中途有障碍物,要绕过才能到达。BC和BH是绕过障碍物的2条路径(假设只有2条)。各个路径的距离d已经标定。

        b图是t=0时刻蚂蚁状态,各个边上有相等的信息素浓度,假设为15;

        c图是t=1时刻蚂蚁经过后的状态,各个边的信息素浓度,有变化;因为大量蚂蚁的选择概率会不一样,而选择概率是和路径长度相关的。所以越短路径的浓度会越来越大,经过此短路径达到目的地的蚂蚁也会比其他路径多。这样大量的蚂蚁实践之后就找到了最短路径。所以这个过程本质可以概括为以下几点:

        1.路径概率选择机制信息素踪迹越浓的路径,被选中的概率越大

        2.信息素更新机制路径越短,路径上的信息素踪迹增长得越快

        3.协同工作机制蚂蚁个体通过信息素进行信息交流。

        从蚂蚁觅食的原理可见,单个个体的行为非常简单蚂蚁只知道跟踪信息素爬行并释放信息素,但组合后的群体智能又非常高蚂蚁群能在复杂的地理分布的清况下,轻松找到蚁穴与食物源之间的最短路径。这种特点恰恰与元启发算法的特点相一致,蚁群优化算法正是受到这种生态学现象的启发后加以模仿并改进而来,觅食的蚂蚁由人工蚁替代,蚂蚁释放的信息素变成了人工信息素,蚂蚁爬行和信息素的蒸发不再是连续不断的,而是在离散的时空中进行。

      上述例子如果不好理解,我在这里贴几张PPT,个人感觉非常不错,也是我找了很多资料觉得最好理解的【来源是大连理工大学谷俊峰】,点击这里提供下载:蚁群算法基本知识.rar

        从深层意义上来讲,蚁群算法作为优化的方法之一,属于人工群集智能领域。人工群集智能,大都受自然群集智能如昆虫群和动物群等的启发而来。除了具有独特的强有力的合作搜索能力外,还可以利用一系列的计算代理对问题进行分布式处理,从而大大提高搜索效率。

    回到目录

    3.群蚁算法的基本流程

      我们还是采用大连理工大学谷俊峰的PPT来说明问题,重要公式进行截图计算和解释,对PPT难以理解的地方进行单独解释:

    3.1 基本数学模型

      首先看看基本TSP问题的基本数学模型:

      问题其实很简单,目标函数就是各个走过路径的总长度,注意的就是距离矩阵根据实际的问题不一样,长度是不一样的。

    3.2 群蚁算法说明

      在说明群蚁算法流程之前,我们对算法原理和几个注意点进行描述:

    1.TSP问题的人工蚁群算法中,假设m只蚂蚁在图的相邻节点间移动,从而协作异步地得到问题的解。每只蚂蚁的一步转移概率由图中的每条边上的两类参数决定:1. 信息素值也称信息素痕迹。2.可见度,即先验值。
    2.信息素的更新方式有2种,一是挥发,也就是所有路径上的信息素以一定的比率进行减少,模拟自然蚁群的信息素随时间挥发的过程;二是增强,给评价值“好”(有蚂蚁走过)的边增加信息素。
    3.蚂蚁向下一个目标的运动是通过一个随机原则来实现的,也就是运用当前所在节点存储的信息,计算出下一步可达节点的概率,并按此概率实现一步移动,逐此往复,越来越接近最优解。
    4.蚂蚁在寻找过程中,或者找到一个解后,会评估该解或解的一部分的优化程度,并把评价信息保存在相关连接的信息素中。 

    3.3 群蚁算法核心步骤

      更加我们前面的原理和上述说明,群蚁算法的2个核心步骤是 路径构建 和 信息素更新。我们将重点对这2个步骤进行说明。

    3.3.1 路径构建

      每个蚂蚁都随机选择一个城市作为其出发城市,并维护一个路径记忆向量,用来存放该蚂蚁依次经过的城市。蚂蚁在构建路径的每一步中,按照一个随机比例规则选 择下一个要到达的城市。随机概率是按照下列公式来进行计算的:

      上述公式就是计算 当前点 到 每一个可能的下一个节点 的概率。分子是 信息素强度 和 能见度 的幂乘积,而分母则是所有 分子的和值。这个刚开始是很不容易理解的,我们在最后实例计算的时候,可以看得很清楚,再反过来理解公式。注意每次选择好节点后,就要从可用节点中移除选择的节点。

    3.3.2 信息素更新

      信息素更新是群蚁算法的核心。也是整个算法的核心所在。算法在初始期间有一个固定的浓度值,在每一次迭代完成之后,所有出去的蚂蚁回来后,会对所走过的路线进行计算,然后更新相应的边的信息素浓度。很明显,这个数值肯定是和蚂蚁所走的长度有关系的,经过一次次的迭代, 近距离的线路的浓度会很高,从而得到近似最优解。那我们看看信息素更新的过程。

      初始化信息素浓度C(0),如果太小,算法容易早熟,蚂蚁会很快集中到一条局部最优路径上来,因为可以想想,太小C值,使得和每次挥发和增强的值都差不多,那么 随机情况下,一些小概率的事件发生就会增加非最优路径的信息素浓度;如果C太大,信息素对搜索方向的指导性作用减低,影响算法性能。一般情况下,我们可以使用贪婪算法获取一个路径值Cnn,然后根据蚂蚁个数来计算C(0) = m/Cnn ,m为蚂蚁个数

      每一轮过后,问题空间中的所有路径上的信息素都会发生蒸发,然后,所有的蚂蚁根据自己构建的路径长度在它们本轮经过的边上释放信息素,公式如下: 

      信息素更新的作用:
    1.信息素挥发(evaporation)信息素痕迹的挥发过程是每个连接上的 信息素痕迹的浓度自动逐渐减弱的过程,这个挥发过程主要用于避 免算法过快地向局部最优区域集中,有助于搜索区域的扩展。
    2.信息素增强(reinforcement)增强过程是蚁群优化算法中可选的部 分,称为离线更新方式(还有在线更新方式)。这种方式可以实现 由单个蚂蚁无法实现的集中行动。基本蚁群算法的离线更新方式是 在蚁群中的m只蚂蚁全部完成n城市的访问后,统一对残留信息进行 更新处理。

    3.3.3 迭代与停止

      迭代停止的条件可以选择合适的迭代次数后停止,输出最优路径,也可以看是否满足指定最优条件,找到满足的解后停止。最重要的是,我刚开始理解这个算法的时候,以为每一只蚂蚁走一条边就是一次迭代,其实是错的。这里算法每一次迭代的意义是:每次迭代的m只蚂蚁都完成了自己的路径过程,回到原点后的整个过程。

    回到目录

    4.群蚁算法计算实例

      使用PPT中的一个案例,非常直观,对几个符号错误进行了修改,主要是计算概率的乘号,结果没有错误:

      过程总体还是比较简单的,注意理解公式,然后把公式和实例结合起来看,最好是拿笔自己手动画一画,容易理解。下面我们来看看如何编程实现TSP问题的群蚁算法代码。

    回到目录

    5.TSP问题的群蚁算法C#代码实现

      百度搜索相关群蚁算法的代码,基本都是matlab的,在CSDN有一个asp.net + C#版本的实现,不过我看了之后果断决定重写,封装不够完善,同时思路也不清楚。所以自己写的过程,理解也更清楚了。经过我的简单更改,目前还说得过去吧,当然后续我还打算继续进行研究,所以先把基本程序的过程写下来,当然是利用了C# 的面向对象特性,看了别人写的 完全面向过程,理解真的很费劲。简单说说实现过程和代码吧。

    5.1 群蚁算法系统基类

      我们封装了一个基础的BaseTspAntSystem类,包括了一些基本属性和计算过程,后续相关改进版本可以进行直接继承。当然设计可能有缺陷,先这样进行,碰到需求再改吧。 BaseTspAntSystem类的主要属性如下:

     1 /// <summary>城市数量,N</summary>
     2 public Int32 NCity { get; set; }
     3 /// <summary>蚂蚁数量,M</summary>
     4 public Int32 AntCount { get; set; }
     5 /// <summary>信息启发式因子a,表征信息素重要程度的参数</summary>
     6 public Double Alpha { get; set; }
     7 /// <summary>期望启发式因子b,表征启发式因子重要程度的参数</summary>
     8 public Double Beta { get; set; }
     9 /// <summary>信息素蒸发的参数p</summary>
    10 public Double Rho { get; set; }
    11 /// <summary>距离数据,不一定是对称矩阵,D=d(ij)</summary>
    12 public Double[,] Distance { get; set; }
    13 /// <summary>最大迭代次数NC</summary>
    14 public Int32 NcMax { get; set; }
    15 /// <summary>最好的解个数,取最优解列表中个数的数目,可以作为备用方案</summary>
    16 public Int32 BetterPlanCount { get; set; }
    17 private List<Ant> planList;
    18 /// <summary>信息素浓度</summary>
    19 public double[,] InfoT { get; set; }

      基类有一个构造函数,对系统的初始化就是传入基本的参数,并对相关列表进行初始化,代码如下:

     1 /// <summary>构造函数</summary>
     2 /// <param name="m">蚂蚁数量</param>
     3 /// <param name="a">信息启发式因子</param>
     4 /// <param name="b">期望启发式因子</param>
     5 /// <param name="p">信息素蒸发的参数</param>
     6 /// <param name="distance">距离数据</param>
     7 /// <param name="NCMax">最大迭代次数</param>
     8 /// <param name="planCount">最优解的个数</param>
     9 public BaseTspAntSystem(double[,]distance,Int32 m,double a,double b,double p,int NCMax,int planCount=10)
    10 {
    11     this.AntCount = m;
    12     this.Alpha = a;
    13     this.Beta = b;
    14     this.Rho = p;
    15     this.Distance = distance;
    16     this.NcMax = NCMax;
    17     this.BetterPlanCount = planCount;
    18     planList = new List<Ant>();
    19     NCity = Distance.GetLength(0);//所有的城市个数
    20     InfoT = new double[NCity, NCity];//初始化信息素矩阵
    21 }

       核心的是求解过程,完全按照迭代次数要求进行迭代进行,过程就是概率选择和信息素更新,我们辅助的用到了Ant蚂蚁类,目的就是让程序更加独立和容易理解。Ant类里面有蚂蚁路径寻找过程的所有信息。下一节将进行介绍。求解过程代码如下面,看看注释和对比算法进行:

    1 public void TspSolution()
     2 {
     3     #region 初始化计算
     4     //计算初始信息素的值,可直接指定,或者贪婪算法计算
     5     double Cnn = GreedyAlgorithm();
     6     double t0 = (double)AntCount / Cnn;//信息素初始化
     7     for (int i = 0; i < NCity; i++)
     8     {
     9         for (int j = 0; j < NCity; j++)
    10         {
    11             //每条可行的路径的信息素初始值
    12             if (Distance[i, j] != 0) InfoT[i, j] = t0;
    13         }
    14     }
    15     //为每个蚂蚁随机选择出发城市,List的长度为蚂蚁个数,内部List长度为路径    
    16     List<Int32> allNodes = new List<int>();
    17     for (int i = 0; i < NCity; i++) allNodes.Add(i);//所有路径节点
    18     //迭代次数
    19     Int32 NC = 0;
    20     #endregion
    21 
    22     while (NC<NcMax)
    23     {
    24         //生成蚂蚁及初始访问城市,并设置对应禁忌表和路径列表
    25         List<Ant> antList = new List<Ant>();
    26         for (int i = 0; i < AntCount; i++)
    27             antList.Add(new Ant(i, allNodes.DeepCopy(), false));
    28         //所有蚂蚁依次寻找下一个节点,直到本轮完成
    29         antList.ForEach(n => n.NextCityUntilFinished(InfoT,Distance,Alpha,Beta,Rho));               
    30         //统计最优解
    31         planList.AddRange(antList);//先添加
    32         planList = planList.OrderBy(n => n.CpathLength).ToList();//排序
    33         //取出前面指定的几条最短路径
    34         if (planList.Count > BetterPlanCount) 
    35             planList.RemoveRange(BetterPlanCount, planList.Count - BetterPlanCount);
    36         NC++;
    37         //更新信息素的值:循环所有路径,依次进行添加
    38         //先挥发
    39         for (int i = 0; i < NCity; i++) //挥发过程
    40         {
    41             for (int j = 0; j < NCity; j++) InfoT[i, j] *= (1.0 - Rho);
    42         }
    43         //再增强,循环所有蚂蚁
    44         foreach (var item in antList)
    45         {
    46             var temp =  1.0 / item.CpathLength;
    47             foreach (var edge in item.Edge) InfoT[edge.Key, edge.Value] += temp;    
    48         }
    49     }
    50 }

    5.2 蚂蚁功能类

       根据算法的描述,m只蚂蚁同时进行自己的工作和寻找路程,是一个并行的过程,因此也在单次过程中,蚂蚁都是独立的。蚂蚁的每一次迭代,过程都比较清楚,寻找路径过程,注意维护一些可用的节点列表,以及最后一条路径的处理。看看蚂蚁类的主要属性和构造函数:

    1 public class Ant
     2 {
     3     #region 属性
     4     /// <summary>蚂蚁编号</summary>
     5     public Int32 Id { get; set; }
     6     /// <summary>当前蚂蚁已经走过的路径节点列表,也就是禁忌表
     7     /// 最后1个就是当前所处的位置
     8     /// </summary>
     9     public List<Int32> PathNodes { get; set; }
    10     /// <summary>当前蚂蚁下一步可供选择的节点列表</summary>
    11     public List<Int32> selectNodes { get; set; }
    12     /// <summary>该蚂蚁旅行的总长度</summary>
    13     public Double CpathLength { get; set; }
    14     /// <summary>当前蚂蚁走过的边,key为起点,value为终点</summary>
    15     public Dictionary<int, int> Edge;
    16     private Random rand;
    17     int N;
    18     #endregion
    19 
    20     #region 构造函数
    21     /// <summary>构造函数</summary>
    22     /// <param name="id">蚂蚁编号</param>
    23     /// <param name="allNodes">所有节点名称列表</param>
    24     /// <param name="isFixStart">是否固定起点</param>
    25     public Ant(Int32 id,List<Int32> allNodes,Boolean isFixStart)
    26     {
    27         this.Id = id;
    28         this.selectNodes = allNodes;
    29         this.PathNodes = new List<int> ();
    30         //isFixStart为false给蚂蚁随机1个起点,否则都为0
    31         if (isFixStart)
    32         {
    33             this.PathNodes.Add(0);
    34             this.selectNodes.RemoveAt(0);
    35         }
    36         else
    37         {
    38             var temp = new Random().Next(0, allNodes.Count - 1);
    39             this.PathNodes.Add(temp);
    40             this.selectNodes.RemoveAt(temp);
    41         }
    42         this.CpathLength = 0;
    43         rand = new Random();
    44     }
    45     #endregion
    46 }

      Ant类的核心是寻找下一个城市节点的过程,以及循环直到所有路径都完成。如下面代码,是一个循环过程:

    1 #region 蚂蚁行为-依次按概率选择下一个城市,直到走完
     2 public void NextCityUntilFinished(double[,] info,double[,] distance,double a,double b,double p)
     3 {
     4     N = distance.GetLength(0);
     5     Edge = new Dictionary<int, int>();//经过的边:起点-终点
     6     //为空,就不需要计算了
     7     while(selectNodes.Count >0)
     8     {
     9         double sumt = 0;//分母的和值
    10         Int32 current = PathNodes.Last();
    11         //依次计算当前点到其他点可选择点的 值
    12         Dictionary<Int32, double> dic = new Dictionary<int, double>();
    13         foreach (var item in selectNodes)
    14         {
    15             var temp = Math.Pow(info[current, item], a) * Math.Pow(1.0 / distance[current, item], b);
    16             sumt += temp;
    17             dic.Add(item, temp);
    18         }
    19         //计算各个点的概率
    20         var ratio = dic.ToDictionary(n => n.Key, n => n.Value / sumt);
    21         //产生1个随机数,并按概率确定下一个城市
    22         Int32 nextCity = GetNextCityByRandValue(ratio, rand.NextDouble());
    23         //修改列表
    24         this.PathNodes.Add(nextCity);
    25         this.selectNodes.Remove(nextCity);
    26         this.CpathLength += distance[current, nextCity];
    27         Edge.Add(current, nextCity);//信息素增强辅助计算
    28     }
    29     //最后1条路径的问题,额外增加,直接 回原点
    30     this.CpathLength += distance[PathNodes.Last(), PathNodes.First()];
    31     Edge.Add(PathNodes.Last(), PathNodes.First());
    32     this.PathNodes.Add(PathNodes.First());//最后才添加           
    33 }
    34 
    35 /// <summary>按照dic中按照顺序的节点的概率值,和随机数rnd的值,确定哪一个为下一个城市</summary>
    36 /// <param name="dic"></param>
    37 /// <param name="rnd"></param>
    38 /// <returns></returns>
    39 int GetNextCityByRandValue(Dictionary<Int32,double> dic,double rnd)
    40 {
    41     double sum = 0;
    42     foreach (var item in dic)
    43     {
    44         sum += item.Value;
    45         if (rnd < sum) return item.Key;
    46         else continue;
    47     }
    48     throw new Exception("无法选择城市");
    49 }
    50 #endregion

      后面的GetNextCityByRandValue是一个辅助函数,进行随机概率值的选择,确定是否选择哪一个节点。

    回到目录

    6.资源与参考文献

      基本TSP问题的C#代码下载:AcaSolution-150913.rar

      如果下载有问题,请到本文原文下载:群蚁算法理论与实践全攻略——旅行商等路径优化问题的新方法 

    [1].什么是NP问题.http://blog.csdn.net/yangtrees/article/details/8107563

    [2].文永军.旅行商问题的两种智能算法[M].西安电子科技大学,2010年

    [3].杨瑞臣.有时间窗和在前约束车辆路径问题的蚁群优化[M].西安建筑科技大学,2005.

    [4].谷俊峰.智能算法-第七章:蚁群算法 PPT,大连理工大学,下载:蚁群算法基本知识.rar

    展开全文
  • 完整代码可直接运行,运行效果图见压缩包
  • #资源达人分享计划#
  • 多目标蚁群算法路径规划(二)------一个简单的体积约束路径规划例子 系列前言(一定要看) 本系列为总结本人近一年多关于启发式算法解决路径规划的相关内容。主要从以下几个主题内容进行系列写作1.常见的数据获取...

    多目标蚁群算法路径规划(二)------一个简单的体积约束路径规划例子

    系列前言(一定要看)

    • 本系列为总结本人近一年多关于启发式算法解决路径规划的相关内容。主要从以下几个主题内容进行系列写作1.常见的数据获取方式与处理过程、2、算法的基础流程3.常见算法改进4.多目标排序5.基于应用场景的改进6.其他相关问题7、批量运行测试数据本系列全程免费提供相关代码。
    • 本系列代码来源主要参考网上相关博客与文献、根据不同实际需求重构的代码。
    • 本文所有提供的代码与文字说明仅供参考,不作为商业目的。
    • 对内容有疑问或是错误部分可以留言或私信。
    • 有偿定制特定功能, qq:1602480875。价格范围60—500。(建议优先看完系列内容,尝试系列中的代码,这些都是免费且能解决大部分问题。),具体代码后续会以完整形式上传百度云。
      更新时间:2021年5月21日

    1.1 本章内容说明

    • 体积约束路径规划启发式算法例子分析
    • 算法设计思路解析
    • 分步详细分析代码过程
    • 基于体积/质量约束的变体例子
    • 算法的设计思路与流程
    • 相关代码汇总总结
    • 下期预告

    1.2 本章主要分享内容简介(摘要)

    • 本章将以一个基础的体积约束循环发车的路径规划(VRP)例子作为切入点,分析一个该问题的代码实现过程与设计思路。具体讲解代码的每一关键设计过程以及常用改进的关键点比如:收敛性搜索域空间的改变搜索权重的变化车辆运行相关的约束设计(例如:满意度、满载率等)。本章节不会去具体介绍相关启发式算法具体原理,需要根据读者自行学习查找(后续可能更新)。
    • 第二部分讲解基于基础VRP算法的变体解决特点需求规划例子实例内容:现需要求解从起始点出车辆在规定时间内去向不同地点进行服务最后返回起始点,每个地点包含位置、服务时间需求、服务收益。路径规划要求以最大收益作为第一目标,次要目标为寻求最大收益中路径最短的规划方案。

    2体积约束路径规划启发式算法例子分析

    2.1问题背景简单描述

    1.路径规划过程中分为简单的旅行商问题(TSP),即车辆从起点出发走完全
    部路径最后返回原点的过程。唯一的约束要求运行的点不能重复,目标函
    数是寻找短路径。
    

    2.由于实际问题的种类差异需要求对求解问题设定不同的约束条件。在
    此背景下演变出多种类型的路径规划问题。其中最为简单和基础的约束条件
    为设定车辆能够承载的质量、体积、速度、时间成本等条件是有限的。这要
    求车辆需要在有限的约束条件搜寻路径。当超过约束条件时进行返回起点重
    新出发,或是停止运行。这种问题通常叫做VRP路径规划。
    

    2.2 本章例子使用的基础代码https://blog.csdn.net/qq_33980829/article/details/105939579

    3算法设计思路解析

    3.1 算法求解流程图

    在这里插入图片描述

    3.2 算法解析说明

    • 1 首先根据需求需要先导入车辆信息、路径信息、位置信息、地点的需求信息。根据导入的信息进行求解可行路径。(提前统一单位,减少运算过程中的问题)(合理设置数据,具体参考本系列上篇内容)
    • 2 随机生成n条路径,根据车辆质量约束条件筛选可行的路径。(初始路径数目,通常为两倍于地点数目)
    • 3 筛选的计算过程为:判断当前剩余空间计算下一个点需要的利用的空间,当满足装置时保留点。当超出车辆最大装置量时则返回起点清空装置。(约束条件的关键控制部分,基础变体的主要可变部分)
    • 4 最后判断是否全部数据点都以运输完全,当没有运输完全时重新出发。(控制循环发车)
    • 5 根据每代最优来更新生成路径的方式与生成方向。(决定求解过程中的收敛性)
    • 6 记录运行过程中最优的结果与每代生成平均结果用于反应解的收敛情况。(也用于比较不同算法间的求解效果)

    4 分步详细分析代码过程

    • 数据导入
    microsoftexcel = xlsread('煤矿分布表.xlsx','路径信息','A1:B9');
    
    • 需要判断过程 车辆装载与需求点的关系*(此处可以根据需求变化,例如转变为收货过程、同时满足2个约束条件或满足两个条件中的任意一个,或者可以两者的其他逻辑来控制约束方式)。*
     if Cap_1-Demand(J(1,k),1)>=0 &&  Cap_2-Demand(J(1,k),2)>=0 %如果车辆装载量大于待访问城市需求量
    
    • 求解最优路径结果 (改变此处可以调整求解搜寻的方向)
      L_best(nC)=min(L);             %最优路径为距离最短的路径
        pos=find(L==min(L));           %找出最优路径对应的位置:即为哪只蚂蚁
        R_best(nC,:)=Route(pos(1),:);  %确定最优路径对应的城市顺序
        L_ave(nC)=mean(L)';            %求第k次迭代的平均距离
    
    • 信息素更新规则
      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);
        end
    
    • 当需要控制迭代过程中的收敛性时,可以设置相关的更新系数。例如:前期产生的随机路径更加多,中期稳定在特定值,后期减少随机的产生。利于数据结果兼顾收敛性好、搜索空间大。(并非重要步骤,可以去除)
      %% 基于迭代次数控制挥发程度
                switch nC
                    case nC<iter_max/3
                        Rho=0.2;
                    case nC<2*iter_max/3 && nC>iter_max/3
                        Rho=0.3;
                    otherwise
                        Rho=0.5;
                end
    
    • 结果绘制(自行看代码中的注释)
    figure(1)%作迭代收敛曲线图
    x=linspace(0,iter_max,iter_max);
    y=L_best(:,1);
    plot(x,y);
    xlabel('迭代次数'); ylabel('最大成本变化');
    saveas(gcf,'迭代过程.jpg')
    figure(2)   %作最短路径图
    [~,m]=max(best_route_2(:,2));
    Shortest_Route=xx_1(m,:);
    plot(C(Shortest_Route,1),C(Shortest_Route,2),'*-');
    grid on
    for i =1:size(C,1)
        text(C(i,1),C(i,2),['   ' num2str(i)]);
    end
    xlabel('客户所在横坐标'); ylabel('客户所在纵坐标');
    saveas(gcf,'路径结果.jpg')
    
    

    5. 基于体积/质量约束的变体例子

    5.1需求背景介绍

    • 补给船在坐标原点,如果补给时间有限每艘船被补给的价值不一样。假设条件是补给船的航速恒定为V km/h,编队内的每艘船的补给位置相对固定。货轮的补给价值是n_1,对它进行补给所需的时间为m 1小时;商船补给价值是n_1,补给所需的时间为m_2小时;游轮补给价值是n_3,补给所需的时间为m_3小时,可用时间总共为m_4小时,怎样在m_4小时内进行路径规划,使补给价值达到最大最后输出的结果为最大补给价值下的最优路径.要求速度可变。

    5.2 例子代码以及运行结果

    https://blog.csdn.net/qq_33980829/article/details/117120590(完整版于6.20号后分享)
    番外篇
    https://blog.csdn.net/qq_33980829/article/details/117395842

    5.3 算法的设计思路与流程关键点

    • 1 车辆每次运输前计算运输消耗的时间
    • 2 当时间消耗完全时返回起点,记录当前生成路径。
    • 3 记录每次运行生成的最大价值对应的最短路径。

    5.4 程序设计流程图

    • 待后续补充

    6. 相关代码汇总总结

    -路径规划结果
    在这里插入图片描述

    • 最大价值的最短路径寻找
      在这里插入图片描述

    -运行输出结果
    在这里插入图片描述
    在这里插入图片描述

    • 待后续补充

    下期内容说明

    基础待时间窗口路径规划算法算法

    展开全文
  • 蚁群算法(ant colony optimization, ACO),又称蚂蚁算法,是一种用来寻找优化路径的机率型算法。它由Marco Dorigo于1992年在他的博士论文中提出,其灵感来源于蚂蚁在寻找食物过程中发现路径的行为。遗传算法在模式...

    一、蚁群算法简介

    1 引言
    在自然界中各种生物群体显现出来的智能近几十年来得到了学者们的广泛关注,学者们通过对简单生物体的群体行为进行模拟,进而提出了群智能算法。其中, 模拟蚁群觅食过程的蚁群优化算法(Ant
    Colony Optimization, A CO) 和模拟鸟群运动方式的粒子群算法(ParticleS warm Optimization,PSO) 是两种最主要的群智能算法。
    蚁群算法是一种源于大自然生物世界的新的仿生进化算法,由意大利学者M.Dorigo, V.Mani ezzo和A.Color ni等人于20世纪90年代初期通过模拟自然界中蚂蚁集体寻径行为而提出的一种基于种群的启发式随机搜索算法[1].蚂蚁有能力在没有任何提示的情形下找到从巢穴到食物源的最短路径,并且能随环境的变化,适应性地搜索新的路径,产生新的选择。其根本原因是蚂蚁在寻找食物时,能在其走过的路径上释放一种特殊的分泌物――信息素2,随着时间的推移该物质会逐渐挥发,后来的蚂蚁选择该路径的概率与当时这条路径上信息素的强度成正比。当一条路径上通过的蚂蚁越来越时,其留下的信息素也越来越多,后来蚂蚁选择该路径的概率也就越高,从而更增加了该路径上的信息素强度。而强度大的信息素会吸引更多的蚂蚁,从而形成一种正反馈机制。通过这种正反馈机制,蚂蚁最终可以发现最短路径。
    最早的蚁群算法是蚂蚁系统(Ant System, AS) , 研究者们根据不同的改进策略对蚂蚁系统进行改进并开发了不同版本的蚁群算法,并成功地应用于优化领域。用该方法求解旅行商(TSP) 问题、分配问
    题、车间作业调度(job-shop) 问题, 取得了较好的试验结果[3

    展开全文
  • 多目标蚁群算法路径规划(2.5)------番外篇 系列前言(一定要看) 本系列为总结本人近一年多关于启发式算法解决路径规划的相关内容。主要从以下几个主题内容进行系列写作1.常见的数据获取方式与处理过程、,2、...
  • 需要的加Q1104498813
  • 整体论文研究了半天没法上传,就把中间的几部分的代码上传了。 1.无人机属性预处理 #include&amp;lt;bits/stdc++.h&amp;gt; using namespace std; #define maxn 62 struct point{ ... do...
  • - 本系列为总结本人近一年多关于启发式算法解决路径规划的相关内容。主要从以下几个主题内容进行系列写作**1.常见的数据获取方式与处理过程、**,**2、算法的基础流程**,**3.常见算法改进**,**4.多目标排序**、**5...
  • 蚁群算法路径规划中的实践基于MATLAB实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,234
精华内容 2,093
关键字:

蚁群算法路径规划