精华内容
下载资源
问答
  • 路径优化matlab代码
    千次阅读 多人点赞
    2022-01-21 01:22:48

    遗传算法本人在另一篇博文中已经有记载,本次将遗传算法用于路径规划的代码记录于此,用于大家一起学习 一起进步,如果有用,欢迎点赞。

    1.基于遗传算法的栅格法机器人路径规划main.m

    % 基于遗传算法的栅格法机器人路径规划
    %jubobolv369
    clc;
    clear;
    % 输入数据,即栅格地图.20行20列
    Grid=  [0 0 0 0 0 0 0 0 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 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0;
         0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0;
         0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0;
         0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
         0 1 1 1 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0;
         0 0 0 0 0 0 1 1 1 0 1 0 1 1 0 0 0 0 0 0;
         0 1 1 1 0 0 0 0 0 0 1 0 1 1 0 0 0 0 0 0;
         0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0;
         0 0 0 0 0 0 0 1 1 0 1 1 1 1 0 0 0 0 0 0;
         0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0;
         0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 1 1 0;
         0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0;
         0 0 1 1 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 0;
         0 0 1 1 0 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0;
         0 0 0 0 0 0 1 1 1 0 1 0 0 0 0 0 0 1 1 0; 
         0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0;
         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 0 0 0 0 0 0 0];
     
    start_num = 0;    % 起点编号
    end_num = 399;    % 终点序号
    NP = 200;       % 种群数量
    max_gen = 50;  % 最大进化代数
    pc = 0.8;      % 交叉概率
    pm = 0.2;      % 变异概率
    a = 1;         % 路径长度比重
    b = 7;         % 路径顺滑度比重
    z = 1;         
    new_pop1 = {}; % 元胞数组,存放路径
    [y, x] = size(Grid);
    % 起点所在列(从左到右编号1.2.3...)
    start_column = mod(start_num, x) + 1; 
    % 起点所在行(从上到下编号行1.2.3...)
    start_row = fix(start_num / x) + 1;  %Y = fix(X) 将 X 的每个元素朝零方向四舍五入为最近的整数
    % 终点所在列、行
    end_column = mod(end_num, x) + 1;
    end_row = fix(end_num / x) + 1;
     
    %% 种群初始化step1,必经节点,从起始点所在行开始往上,在每行中挑选一个自由栅格,构成必经节点
    pass_num = end_row - start_row + 1;  %每条路径的节点个数
    pop = zeros(NP, pass_num);%生成种群数量*节点个数的矩阵,用于存放每个个体的路径
    for i = 1 : NP  %每个个体(每行)循环操作:
        pop(i, 1) = start_num;   %每行第一列都为起点(存入起点的编号)
        j = 1;
        % 此for循环用于寻找除去起点和终点所在行以外每行中的自由栅格
        for row_i = start_row+1 : end_row-1   %栅格的第二行到倒数第二行循环
            j = j + 1;
            % 存放栅格里当前行中的自由栅格序号
            free = []; 
            for column_i = 1 : x   %从第一列到第二十列中
                % 栅格对应的序号
                num = (column_i - 1) + (row_i - 1) * x;
    % 如果该栅格为非障碍物
                if Grid(row_i, column_i) == 0
                    % 把此栅格的编号加入free矩阵中
                    free = [free num];
                end
            end     % 栅格一行里的自由栅格查询结束,自由栅格的编号存在了向量中
    
            free_num = length(free);
            % 产生小于等于本行自由栅格数量的一个随机整数
            index = randi(free_num); %X = randi(imax) 返回一个介于 1 和 imax 之间的伪随机整数标量。
            % 将栅格中当前行的自由栅格矩阵free中第index个栅格编号作为当前种群的第j个节点
            pop(i, j) = free(index);
          end  %该个体的每一行的路径节点产生完成,存入了pop的第i行中
        pop(i, end) = end_num; %pop的每行第最后一列都为终点(存入终点的编号)
        
    
    
    
    
    %% 种群初始化step2将上述必经节点联结成无间断路径
        single_new_pop = generate_continuous_path(pop(i, :), Grid, x);
      
        if ~isempty(single_new_pop)%如果这一行种群的路径不是空的,将这行路径存入元胞数组中。
           new_pop1(z, 1) = {single_new_pop};
            z = z + 1;
        end
    end
     
    %% 计算初始化种群的适应度
    % 计算路径长度
    path_value = cal_path_value(new_pop1, x);
    % 计算路径平滑度
    path_smooth = cal_path_smooth(new_pop1, x);
    fit_value = a .* path_value .^ -1 + b .* path_smooth .^ -1;
     
    mean_path_value = zeros(1, max_gen);
    min_path_value = zeros(1, max_gen);
    %% 循环迭代操作
    for i = 1 : max_gen
        % 选择操作
        new_pop2 = selection(new_pop1, fit_value);
        % 交叉操作
        new_pop2 = crossover(new_pop2, pc);
        % 变异操作
        new_pop2 = mutation(new_pop2, pm, Grid, x);
        % 更新种群
        new_pop1 = new_pop2;
        % 计算适应度值
        % 计算路径长度
        path_value = cal_path_value(new_pop1, x)
        % 计算路径平滑度
        path_smooth = cal_path_smooth(new_pop1, x)
        fit_value = a .* path_value .^ -1 + b .* path_smooth .^ -1
        mean_path_value(1, i) = mean(path_value);
        [~, m] = max(fit_value);
        min_path_value(1, i) = path_value(1, m);
    end
    %% 画每次迭代平均路径长度和最优路径长度图
    figure(1)
    plot(1:max_gen,  mean_path_value, 'r')
    hold on;
    title(['a = ', num2str(a)', ',b = ',num2str(b)','的优化曲线图']); 
    xlabel('迭代次数'); 
    ylabel('路径长度');
    plot(1:max_gen, min_path_value, 'b')
    legend('平均路径长度', '最优路径长度');
    min_path_value(1, end)
    % 在地图上画路径
    [~, min_index] = max(fit_value);
    min_path = new_pop1{min_index, 1};
    figure(2)
    hold on;
    title(['a = ', num2str(a)', ',b = ',num2str(b)','遗传算法机器人运动轨迹']); 
    xlabel('坐标x'); 
    ylabel('坐标y');
    DrawMap(Grid);
    [~, min_path_num] = size(min_path);
    for i = 1:min_path_num
        % 路径点所在列(从左到右编号1.2.3...)
        x_min_path(1, i) = mod(min_path(1, i), x) + 1; 
        % 路径点所在行(从上到下编号行1.2.3...)
        y_min_path(1, i) = fix(min_path(1, i) / x) + 1;
    end
    hold on;
    plot(x_min_path, y_min_path, 'r')
    

    2.将必经节点联结成无间断路径,如果结点间不连续,则插入节点使其连续generate_continuous_path.m

    % 将必经节点联结成无间断路径,如果结点间不连续,则插入节点使其连续。
    %jubobolv369
    function [single_new_pop] = generate_continuous_path(single_pop, Grid, x)
    i = 1;
    single_new_pop = single_pop;  %传入的某行的初始路径,有20个路径节点
    [~, single_path_num] = size(single_new_pop);
    %遍历该行的所有节点,使其连续
    while i ~= single_path_num
    %%定位第i、i+1个节点的坐标
        % 路径中第i个栅格在地图的列(从左到右编号1.2.3...)
        column_now = mod(single_new_pop(1, i), x) + 1; 
        % 路径中第i个栅格在地图的行(从上到下编号行1.2.3...)
        row_now = fix(single_new_pop(1, i) / x) + 1;
        % 路径中第i+1个栅格在地图的列、行
        column_next = mod(single_new_pop(1, i + 1), x) + 1;
        row_next = fix(single_new_pop(1, i + 1) / x) + 1;
        
        % 初始化最大迭代次数
        max_iteration = 0;
        
        %% 判断点i和i+1是否连续,若不连续插入值(如果前后两节点的X坐标与Y坐标的差中较大值不等于1,说明不连续)
    while max(abs(column_next - column_now), abs(row_next - row_now)) ~= 1
    %取两节点的中点作为插入点,见forGA_word.xls-sheet1
    %插入点的横坐标 x_insert,纵坐标 y_insert
            x_insert = floor((column_next + column_now) / 2);%Y = floor(X) 将 X 的每个元素四舍五入到小于或等于该元素的最接近整数。
            y_insert = floor((row_next + row_now) / 2);
            
            % 插入栅格为自由栅格
            if Grid(y_insert, x_insert) == 0  
                % 插入的栅格序号
                num_insert = (x_insert - 1) + (y_insert - 1) * x;
                % 插入新序号(将当前的栅格序号中间插入一个新栅格序号 其他保持不变)
                single_new_pop = [single_new_pop(1, 1:i), num_insert, single_new_pop(1, i+1:end)];
                
            % 插入栅格为障碍物栅格
            else   
                % 往左走(如果当前待插入格(障碍物格)的左邻格不是障碍物 且 左邻格不是当前研究的两个格中任意一个)
                if Grid(y_insert, x_insert - 1) == 0 && ((x_insert - 2) + (y_insert - 1) * x ~= single_new_pop(1, i)) && ((x_insert - 2) + (y_insert - 1) * x ~= single_new_pop(1, i+1))
                    x_insert = x_insert - 1;
                    % 栅格序号
                    num_insert = (x_insert - 1) + (y_insert - 1) * x;
                    % 插入新序号
                    single_new_pop = [single_new_pop(1, 1:i), num_insert, single_new_pop(1, i+1:end)];
                                   
                % 往右走 (如果当前待插入格(障碍物格)的右邻格不是障碍物 且 右邻格不是当前研究的两个格中任意一个)   
                elseif Grid(y_insert, x_insert + 1) == 0 && (x_insert + (y_insert - 1) * x ~= single_new_pop(1, i)) && (x_insert + (y_insert - 1) * x ~= single_new_pop(1, i+1))
                    x_insert = x_insert + 1;
                    % 栅格序号
                    num_insert = (x_insert - 1) + (y_insert - 1) * x;
                    % 插入新序号
                    single_new_pop = [single_new_pop(1, 1:i), num_insert, single_new_pop(1, i+1:end)];
                    
                % 向上走
                elseif Grid(y_insert + 1, x_insert) == 0 && ((x_insert - 1) + y_insert * x ~= single_new_pop(1, i)) && ((x_insert - 1) + y_insert * x ~= single_new_pop(1, i+1))
                    y_insert = y_insert + 1;
                    % 栅格序号
                    num_insert = (x_insert - 1) + (y_insert - 1) * x;
                    % 插入新序号
                    single_new_pop = [single_new_pop(1, 1:i), num_insert, single_new_pop(1, i+1:end)];
     
                % 向下走
                elseif  Grid(y_insert - 1, x_insert) == 0 && ((x_insert - 1) + (y_insert - 2) * x ~= single_new_pop(1, i)) && ((x_insert - 1) + (y_insert-2) * x ~= single_new_pop(1, i+1))
                    y_insert = y_insert - 1;
                    % 栅格序号
                    num_insert = (x_insert - 1) + (y_insert - 1) * x;
                    % 插入新序号
                    single_new_pop = [single_new_pop(1, 1:i), num_insert, single_new_pop(1, i+1:end)];
                    
                % 如果各方向都无法插入则舍去此路径
                else
                    %break_pop = single_new_pop
                    single_new_pop = [];
                    break
                end    
            end
            
            column_next = x_insert;
            row_next = y_insert;
            max_iteration = max_iteration + 1;
    %如果可以不断的增加新节点,但增加次数超过20000次,则舍弃此路径
            if max_iteration > 20000
                single_new_pop = [];
                break
            end
            
        end
        
        if isempty(single_new_pop)
            break
        end
        
        [~, single_path_num] = size(single_new_pop);
        i = i + 1;
    end
    

    3.计算路径长度函数cal_path_value.m

    %% 计算路径长度函数
    %jubobolv369
    function [path_value] = cal_path_value(pop, x)
    [n, ~] = size(pop);
    path_value = zeros(1, n);
    %循环计算每一条路径的长度
    for i = 1 : n
        single_pop = pop{i, 1};
        [~, m] = size(single_pop);
        %路径有m个栅格,需要计算m-1次
        for j = 1 : m - 1
            % 点i所在列(从左到右编号1.2.3...)
            x_now = mod(single_pop(1, j), x) + 1; 
            % 点i所在行(从上到下编号行1.2.3...)
            y_now = fix(single_pop(1, j) / x) + 1;
            % 点i+1所在列、行
            x_next = mod(single_pop(1, j + 1), x) + 1;
            y_next = fix(single_pop(1, j + 1) / x) + 1;
            %如果相邻两个栅格为上下或左右,路径长度加1,否则为对角线,长度加根号2
            if abs(x_now - x_next) + abs(y_now - y_next) == 1
                path_value(1, i) = path_value(1, i) + 1;
            else
                path_value(1, i) = path_value(1, i) + sqrt(2);
            end
        end
    end
    

    4.计算路径平滑度函数cal_path_smooth.m

    %% 计算路径平滑度函数
    %jubobolv369
    function [path_smooth] = cal_path_smooth(pop, x)
    [n, ~] = size(pop);
    path_smooth = zeros(1, n);
    %循环计算每一条路径的平滑度
    for i = 1 : n
        single_pop = pop{i, 1};
        [~, m] = size(single_pop);
        %路径有m个栅格,需要计算m-1次
        for j = 1 : m - 2
            % 点i所在列(从左到右编号1.2.3...)
            x_now = mod(single_pop(1, j), x) + 1; 
            % 点i所在行(从上到下编号行1.2.3...)
            y_now = fix(single_pop(1, j) / x) + 1;
            % 点i+1所在列、行
            x_next1 = mod(single_pop(1, j + 1), x) + 1;
            y_next1 = fix(single_pop(1, j + 1) / x) + 1;
            % 点i+2所在列、行
            x_next2 = mod(single_pop(1, j + 2), x) + 1;
            y_next2 = fix(single_pop(1, j + 2) / x) + 1;
            %path_smooth(1, i) = path_smooth(1, i) + abs(atan(abs(x_now - x_next1)/abs(y_now - y_next1))-atan(abs(x_next2 - x_next1)/abs(y_next2 - y_next1)));
            %a2 = (x_now - x_next1)^2 + (y_now - y_next1)^2;
            %b2 = (x_next2 - x_next1)^2 + (y_next2 - y_next1)^2;
            c2 = (x_now - x_next2)^2 + (y_now - y_next2)^2;
            %angle = (a2 + c2 - b2) / (2 * sqrt(a2) *  sqrt(c2));
            %若大于4小于等于8,说明此栅格与隔一个的栅格隔一行或一列且列或行相邻
            if c2 < 8 && c2 > 4
                path_smooth(1, i) = path_smooth(1, i) + 5;
            %若大于1小于等于4,说明此栅格与隔一个的栅格为对角,也可能或同行或同列垮了一格
            elseif c2 <= 4 && c2 > 1
                path_smooth(1, i) = path_smooth(1, i) + 30;
            %若等于1,说明此栅格与隔一个的栅格是上下或左右相邻,其路径不如直接从此格到邻格,显然冗余了。
            elseif    c2 <= 1
                path_smooth(1, i) = path_smooth(1, i) + 5000;
            %否则不设置值,也即值为0,此时此栅格与隔一个的栅格是正方形对角的关系,最好。
            end
        end
    end

    5.用轮盘堵法选择新的个体selection.m

    %% 用轮盘堵法选择新的个体
    % 输入变量:pop元胞种群,fitvalue:适应度值
    % 输出变量:newpop选择以后的元胞种群
    %jubobolv369
    function [new_pop] = selection(pop, fit_value)
    %构造轮盘
    [px, ~] = size(pop);
    total_fit = sum(fit_value);
    p_fit_value = fit_value / total_fit;
    p_fit_value = cumsum(p_fit_value);    % B = cumsum(A) 从 A 中的第一个其大小不等于 1 的数组维度开始返回 A 的累积和。
    % 随机数从小到大排列
    ms = sort(rand(px, 1));   
    fitin = 1;
    newin = 1;
    while newin <= px
        if(ms(newin)) < p_fit_value(fitin)
            new_pop{newin, 1} = pop{fitin, 1};
            newin = newin+1;
        else
            fitin = fitin+1;
        end
    end
    
    

    6.交叉操作crossover.m

    %%交叉操作
    %输入变量:pop:父代种群,pc:交叉的概率
    %输出变量:newpop:交叉后的种群
    %jubobolv369
    function [new_pop] = crossover(pop, pc)
    [px,~] = size(pop);
    % 判断路径点数是奇数或偶数
    parity = mod(px, 2);
    new_pop = {};
    %两个两个交叉
    for i = 1:2:px-1
            singal_now_pop = pop{i, 1};
            singal_next_pop = pop{i+1, 1};
            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
           %%         A = [5 3 4 2];                %%
           %%         B = [2 4 4 4 6 8];            %%
           %%        [Lia,Locb] = ismember(A,B)     %%
           %%         Lia = 1x4 logical array       %%A的每个元素若B中存在则该位为1 否则为零
           %%                 0   0   1   1         %%
           %%         Locb = 1×4                   %%每个相同的元素在B中的索引
           %%                 0     0     2     1   %%
            %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
            [lia, locb] = ismember(singal_now_pop, singal_next_pop);%[Lia,Locb] = ismember(A,B)确定 A 的哪些元素同时也在 B 中及其在 B 中的相应位置。
            [~, n] = find(lia == 1);%要查找特定的整数值,使用 == 运算符。返回找到的值在lia中的索引
            [~, m] = size(n);
            %如果随机数小于交叉概率且A中有三个以上路径节点与B中的相同
        if (rand < pc) && (m >= 3)
            % 生成一个2到m-1之间的随机数,也就是除去开头和结尾,在两条路径的相同节点中随机选取一个节点用于交叉
            r = round(rand(1,1)*(m-3)) +2;%Y = round(X) 将 X 的每个元素四舍五入为最近的整数
            crossover_index1 = n(1, r);%
            crossover_index2 = locb(crossover_index1);
            new_pop{i, 1} = [singal_now_pop(1:crossover_index1), singal_next_pop(crossover_index2+1:end)];
            new_pop{i+1, 1} = [singal_next_pop(1:crossover_index2), singal_now_pop(crossover_index1+1:end)];
            
        else   %否则不交叉
            new_pop{i, 1} =singal_now_pop;
            new_pop{i+1, 1} = singal_next_pop;
        end
        %如果有奇数条路径,除最后一条外,其余已按照if的条件进行了是否交叉的处理,所以最后一条仍然不变。
    if parity == 1
        new_pop{px, 1} = pop{px, 1};
    end
    end
    

    7.变异操作mutation.m

    %% 变异操作
    % 函数说明
    % 输入变量:pop:种群,pm:变异概率
    % 输出变量:newpop变异以后的种群
    %jubobolv369
    function [new_pop] = mutation(pop, pm, Grid, x)
    [px, ~] = size(pop);
    new_pop = {};
    %对每一行选择是否变异
    for i = 1:px
        % 初始化最大迭代次数
        max_iteration = 0;
        single_new_pop = pop{i, 1};
        [~, m] = size(single_new_pop);
        % single_new_pop_slice初始化
        single_new_pop_slice = [];
        if(rand < pm)
            while isempty(single_new_pop_slice)
                % 生成2到(m-1)的两个随机数,并排序
                mpoint = sort(round(rand(1,2)*(m-3)) + [2 2]);
                %切除掉包含两个随机数在内的之间的路径节点,将切除部分及前后两个节点取出
                single_new_pop_slice = [single_new_pop(mpoint(1, 1)-1) single_new_pop(mpoint(1, 2)+1)];
                %将取出的用于切除的部分路径重新联结成无间断路径(这一步可能变异 也可能不变异)
                single_new_pop_slice = generate_continuous_path(single_new_pop_slice, Grid, x);
                %max_iteration = max_iteration + 1;
                if max_iteration >= 100000
                    break
                end
            end
            if max_iteration >= 100000
                new_pop{i, 1} = pop{i, 1};
            else
                %将变异后的路径保存
                new_pop{i, 1} = [single_new_pop(1, 1:mpoint(1, 1)-1), single_new_pop_slice(2:end-1), single_new_pop(1, mpoint(1, 2)+1:m)];
            end
            % single_new_pop_slice再次初始化
            single_new_pop_slice = [];
        else%不变异
            new_pop{i, 1} = pop{i, 1};
        end
    end
    

    8.创建具有障碍物的栅格地图DrawMap.m

    %创建具有障碍物的栅格地图
    %矩阵中1代表黑色栅格
    %jubobolv369
    function Grid = DrawMap(Grid)
    b = Grid;
    b(end+1,end+1) = 0;
    colormap([1 1 1;0 0 0]);  % 创建颜色
    pcolor(0.5:size(Grid,2) + 0.5, 0.5:size(Grid,1) + 0.5, b); % 赋予栅格颜色
    set(gca, 'XTick', 1:size(Grid,1), 'YTick', 1:size(Grid,2));  % 设置坐标
    axis image xy;  % 沿每个坐标轴使用相同的数据单位,保持一致
    

    如果急看,可至此处,压缩包包含代码和本人学习时候的草稿。喜欢请点赞哦。

     

    链接: https://pan.baidu.com/s/19Z0huAtdR5x2WmBQdAbhHg

    提取码: uzdu

    更多相关内容
  • 拣货路径优化matlab代码持续/终身/增量学习 请随时提出请求或打开问题以添加论文。 快速链接: 苏维 (推荐阅读) 重放方法 2021年 标题 场地 代码 —— —— —— 2020年 标题 场地 代码 ICML —— 统计局 —— ...
  • 拣货路径优化matlab代码这是一个用于 Lynx 机器人(6-DoF 机械手)的动态平滑 RRT 规划器。 主要功能: 模拟函数:runsim.m 静态规划生成函数(主函数):SRRT.m 动态规划的生成函数:regrow.m 其他功能: 示例函数...
  • 选址与路径优化matlab代码STOMPSelfJoin 这是 STOMP 算法的 GPU 实现。 STOMP 将时间序列作为输入并计算特定窗口大小的矩阵轮廓。 您可以在 对于附加功能和更好的性能,您应该使用 环境 这个基础项目需要: 至少有 ...
  • matlab解决路径优化代码 HarrisforDSP C代码实现Harris 针对TI DSP的,ccs版本5.4,没有专门针对DSP做优化 cmd文件针对tms320c6727,确定的是改成6748也能跑,用Simulation.ccxml可以仿真,打印匹配到的角点 ...
  • 拣货路径优化matlab代码使用 SOM 的旅行推销员 (TSP) 在这段代码中,我们说明了如何使用 Kohonen 自组织映射中的集群单元的线性拓扑来解决约束优化中的一个经典问题,即所谓的旅行商问题 (TSP)。 TSP 的目标是找到...
  • 拣货路径优化matlab代码概述 Chapman 等人在提交给 IEEE Transactions on Automatic Control,2021 年 6 月的“通过状态空间增强进行风险敏感的安全分析”中介绍的用于生成图形和工件的分析代码。 依赖关系 计算环境...
  • 基本的matlab蚁群算法求解最短路径问题,里面另附有初始数据
  • matlab代码 Intelligent_Algorithm 用matlab解决路径规划和竞争设施选址问题 一、五个基础算法以及示例: ga 遗传算法解决分配问题 问题描述: 现有10个工人去做10件工作,每个工人完成每项工作所需时间不同。 要求...
  • matlab解决路径优化代码 2020.SRTP 2020.7-2021.5 -- The SRTP Qt project 今天是2021.2.4,这是我第一个同步github的工程,当然也是验证自学成果的第一个工程 该工程基于Qt开发,方向为高铁的动力投切 涉及到Qt对...
  • 滑行冲突影响飞行安全的状态,提出将安全间隔、滑行规则和冲突避免限制规则作为约束条件建立了滑行路径优化模型.采用了A*算法给出了问题的优化,在保证滑行道调度零冲突的前提下,缩小航班的总滑行时间,提高了滑行效率....
  •  一种基于蚁群算法的多配送中心车辆路径优化方法,首先,针对多配送中心车辆路径优化问题,对各个客户点设计了以最近配送中心为启发式信息的惩罚函数;其次,将具有上述启发式信息的罚函数加入到各配送点的信息素更新...

    1模型介绍

     一种基于蚁群算法的多配送中心车辆路径优化方法,首先,针对多配送中心车辆路径优化问题,对各个客户点设计了以最近配送中心为启发式信息的惩罚函数;其次,将具有上述启发式信息的罚函数加入到各配送点的信息素更新过程中,从而提高了算法的搜索效率.本发明在实际物流配送车辆路径优化应用中可以快速的得到可靠的最佳配送路径.

    1.1 多中心VRP模型

    img

    1.2 蚁群算法原理

     蚁群算法(AG)是一种模拟蚂蚁觅食行为的模拟优化算法,它是由意大利学者Dorigo M等人于1991年首先提出,并首先使用在解决TSP(旅行商问题)上。之后,又系统研究了蚁群算法的基本原理和数学模型1、蚂蚁在路径上释放信息素。

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

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

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

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

    1.3 蚁群算法流程图

    img

    2 部分代码

    % 锐镱朦珞 嚯泐痂蜢 祗疣恻桧 觐腩龛?潆 镱耱痤屙? 爨瘌痼蝾? 禧
    % 镱耠邃钼囹咫??镳铞羼皴 恹镱腠屙? 嚯泐痂蜢? 疣玑桠噱?% 爨瘌痼螓 磬 镱潇囵篁? 桉躅? 桤 沭箸钼戾耱桁铖蜩 已
    function [ Route, Length_Route, vehicles ] = ANT_colony_algorithm_VRP( ...
       distances, distances_bases, demands, param, vehicles_capacity ...
    )
    clc
    waitBar = waitbar(0,'Please wait...');
    %%
    %软桷栲腓玎鲨 溧眄
    iter_max = 7; % 100/爨犟桁嚯铄 觐腓麇耱忸 栩屦圉栝
    
    distances = add_bases_to_distances(distances, distances_bases);
    vehicles_capacity = sort(vehicles_capacity,'descend'); %耦痱桊箦?沭箸忸忪羼蜩祛耱?爨??筢帼?镱?潢?demands = [vehicles_capacity(1) demands]; 
    %耦玟噱?耱痼牝箴?溧眄 潆 已, 沅?狍潴?躔囗栩? 桴
    %沭箸铒钿祉铖蜩 ?爨瘌痼螓
    cell_capacities = vehicles_capacities_to_cellarray(vehicles_capacity); %耦躔囗屐 沭箸铒钿祉铖螯 赅驿钽?已
    vehicles = struct('capacity',cell_capacities,'route',cell(1,length(vehicles_capacity)));
    %桧桷栲腓玷痼屐 耱囵蝾怏?徉珞 潆 怦艴 已
    for i = 1:length(vehicles)
       vehicles(i).route = 1;
    end
    nvehicle = 1; %磬麒磬屐 ?1-泐 已
    
    dim = length(distances); %觐腓麇耱忸 泐痤漕?Route = zeros(1,dim); %耦玟噱?爨耨桠 镱?狍潴?爨瘌痼?c = demands(1); %沭箸钼戾耱桁铖螯 1-钽?已
    N_of_vehicles = length(vehicles);
    
    evaporation_fer = param(1);%觐翳鲨屙?桉镟疱龛 翦痤祛磬 [0;1]
    alpha = param(2); %橡?alpha = 0 狍溴?恹狃囗 犭桄嚅?泐痤? 黩?耦铗忮蝰蜮箦?驵漤铎?嚯泐痂?祗 ?觌囫耔麇耜铋 蝈铕梃 铒蜩扈玎鲨? 篷腓
    beta = param(3); %beta = 0, 蝾沅?疣犷蜞弪 腓 翦痤祛眄铄 篑桦屙桢, 黩?怆鬻弪 玎 耦犷?猁耱痤?恹痤驿屙桢爨瘌痼蝾??钿眍祗 耋犷矧桁嚯铎?疱龛?
    tau0 = param(4); %觐腓麇耱忸 翦痤祛磬
    tau = zeros(dim); %爨蝠桷?觐腓麇耱忄 忤痱筻朦睇?翦痤祛眍?eta = zeros(dim); %"忤滂祛耱? 泐痤溧, 痂耱梓羼觐?驽豚龛?镱皴蜩螯 泐痤?j 桤 泐痤溧 i ?麇?犭桄?泐痤? 蝈?犷朦 驽豚龛?镱皴蜩螯 邈?
    Q = 0; %镱?漕?潆桧?铒蜩爨朦眍泐 爨瘌痼蜞
    N_ants = dim; %觐腓麇耱忸 祗疣恻邂
    
    ants_in_cities = zeros(1, N_ants); %祗疣恻??泐痤溧?route_ants = zeros(N_ants, 2*N_ants + 1); %爨瘌痼?潆 赅驿钽?桤 祗疣恻邂
    length_route_ants = zeros(1, N_ants);%潆桧?爨瘌痼蜞 潆 赅驿钽?桤 祗疣恻邂
    entries_in_cities = zeros(1, dim); %爨耨桠 潆 铒疱溴脲龛, 猁?腓 祗疣忮??泐痤溴(1 - 猁? 0 - 礤 猁?
    
    for i = 1:dim
       for j = 1:dim
           if i ~= j
               eta(i,j) = 1/distances(i,j); %忤滂祛耱?           tau(i,j) = tau0; %翦痤祛?       else
               tau(i,j) = 0;
           end
       end  
    end
    %疣珈妁噱?赅驿钽?祗疣恻 ?耠篦嚅眍 恹狃囗睇?泐痤?
    ants_in_cities = randperm(N_ants);
    %蔓徼疣屐 篑腩忭?牮囹鬣轼栝 爨瘌痼?Route ?疣聍栩噱?邈?潆桧?Route = ants_in_cities;
    Length_Route = length_of_route(Route, distances) * 10; %潆 筲屦屙眍耱? 黩??潆桧?礤 '耩噌铗噱?
    Q = Length_Route;
    P = zeros(1, dim); %忮痤蝽铖蜩 镱皴龛 祗疣恻 铗 1-泐 泐痤溧 漕 dim-泐 泐痤溧
    %%
    %----------------------铖眍忭铥?鲨觌---------------------------------------
    for iter = 1: iter_max
       
       for ant = 1: N_ants
           %钺眍怆屐 沭箸钼戾耱桁铖蜩 已
           nvehicle = 1;
           c = vehicles(nvehicle).capacity; 
       %-----------------潆 赅驿钽?祗疣恻 耱痤桁 爨瘌痼??疣耨麒螓忄屐 邈?潆桧?-------
           i = ants_in_cities(ant); %磬躅滂?耱囵蝾恹?泐痤?祗疣恻
           q2 = demands(i); % 磬躅滂?玎镳铖 镳钿箨鲨?镱 泐痤潴(镳邃镱豚汔, 黩?玎镳铖 耱囵蝾忸泐 泐痤溧 礤 镳邂帼?沭箸铎羼蜩祛耱?爨睇)
           entries_in_cities(i) = 1;
           route_ants(ant, 1) = i;
           ind_city_for_route_ant = 1; %镱?潢钼 眍戾?泐痤溧 ?爨瘌痼蝈
           while ~all(entries_in_cities) %镱赅 羼螯 礤 镱皴眄 泐痤溧
                   ind_city_for_route_ant = ind_city_for_route_ant + 1; %镥疱躅滂??桧溴犟?耠邃. 泐痤潴
                   for j = 1: dim
                       %聍栩噱?忮痤蝽铖螯 镱躅溧 ?赅驿 礤 镱皴眄 泐痤?                   if entries_in_cities(j) == 0 %羼腓 礤 镱皴眄 泐痤?                       sum = 0;
                           for el = 1: dim
                               if entries_in_cities(el) == 0
                                   sum = sum + (tau(i,el)^alpha * eta(i,el)^beta);
                               end
                           end
                           P(j) = (tau(i,j)^alpha * eta(i,j)^beta)/sum;
                       end
                   end
                   P(1) = 0; %钺眢?屐 徉珞 ?玎镟襦扈, 赅?磬桠屦?蝽彘?恹犷?               %///
                  [~, city_ind_P_max] = max(P);%磬躅滂?爨犟桁嚯 屐屙??忮牝铕?忮痤蝽铖蝈?               q1 = demands(city_ind_P_max);
                   if q1 + q2 <= c 
                       route_ants(ant, ind_city_for_route_ant) = city_ind_P_max; %漕徉怆屐 泐痤??爨瘌痼?蝈牦泐 祗疣恻
                       entries_in_cities(city_ind_P_max) = 1;
                       i = city_ind_P_max; %耠邃. 泐痤?磬桠屦?蝽邋 ?扈? 疣耨蝾龛屐
                       q2 = q2 + q1;
                   else
                       route_ants(ant, ind_city_for_route_ant) = 1; %忸玮疣?磬 徉珞 玎镟耦?                   entries_in_cities(1) = 1;
                       i = 1; %忸玮疣?磬 徉珞 
                       q2 = 0;
                       nvehicle = get_No_vehicle(nvehicle,N_of_vehicles);
                       c = vehicles(nvehicle).capacity; 
                   end
                   %//
                   %__________________________________________________________
                   P = zeros(1, dim); %钺眢?屐 怦?忮痤蝽铖蜩 ?泐痤溧?               %___________________________________________________________
           end
           route = [1, route_ants(ant, :)];
           route(route == 0) = []; %筢桊噱?礤眢骓 眢腓 
           route(end + 1) = 1; %忸玮疣?磬 徉珞 
           length_route_ants(ant) = length_of_route(route, distances); %聍栩噱?潆桧?爨瘌痼蜞 蝈牦泐 祗疣恻
           entries_in_cities = zeros(1, dim); %铗戾?屐 怦?镱皴龛 泐痤漕?镳邃簌邈?祗疣恻
       %-------------------------------------------------------------------------------------
       
       res = ((iter - 1)+(ant/N_ants))/(iter_max);
       waitbar(res,waitBar,sprintf('Processing... %d %%',round(res*100)));
       
       end
       %___________________________袜殇屙?腓 疱龛?_____________________
      [min_length_route, ind_min_len_route] = min(length_route_ants);
       if Length_Route > min_length_route %羼腓 蝈牦 潆桧?爨瘌痼蜞 犷朦 磬殇屙眍泐 扈龛爨朦眍泐
           Length_Route = min_length_route; %钺眍怆屐 潆桧?蝈牦泐 爨瘌痼蜞
           route = [1, route_ants(ind_min_len_route, :)];
           route(route == 0) = []; 
           Route = [route, 1]; %钺眍怆屐 磬桦篦?爨瘌痼?       Route = delete_duplicates_stations(Route);
           Q = Length_Route;
       end
       %__________________________________________________________________
       %-----------吾眍怆屐 耠邃?翦痤祛磬--------------------------------
       sum_delta_tau = zeros(dim);
       for ant = 1: N_ants
           delta_tau = zeros(dim); %觐腓麇耱忸 翦痤祛磬 磬 赅驿铎 桤 疱徨?       for w = 1:length(route_ants(ant, :)) - 1
               Ri = route_ants(ant, w); Ri(Ri == 0) = [];
               Rj = route_ants(ant, w + 1); Rj(Rj == 0) = [];
               i = Ri;
               j = Rj;
               delta_tau(i,j) = Q/length_route_ants(ant);
           end
           sum_delta_tau = sum_delta_tau + delta_tau;
       end
       tau = (1 - evaporation_fer) * tau + sum_delta_tau;
       tau(1,1) = 0;
       %-------------------------------------------------------------------
       route_ants(:,:) = 0;
    end
    
    %%
    delete(waitBar);
    
    %%
    
    vehicles = create_routes_for_vehicles(vehicles,Route);
    
    %vehicles(1:end).route %桧纛痨圉? ?爨瘌痼蜞?潆 赅驿钽?已
    %Length_Route
    %create_plot_route_with_vehicles(distances,vehicles,demands);
    %_______________________________________________________________________
    %潆 恹忸溧 玎镳铖钼 镱蝠遽栩咫彘
    % sum_demands = 0;
    % for i = 1:length(Route)
    %   if Route(i) == 1
    %       sum_demands
    %       sum_demands = 0;
    %   else
    %       sum_demands = sum_demands + demands(Route(i));
    %   end
    % end
    %_______________________________________________________________________
    end
    
    function [vehicles] = create_routes_for_vehicles(vehicles,ROUTE)
       nvehicle = 1; %磬麒磬屐 ?1-泐 已 
       N_of_vehicles = length(vehicles);
       bases = find(ROUTE == 1); %棂屐 桧溴犟??徉珙??爨瘌痼蝈 
       for i = 1:length(bases) - 1
           ind_start = bases(i) + 1;
           ind_end = bases(i + 1);
           vehicles(nvehicle).route = [ vehicles(nvehicle).route ROUTE(ind_start:ind_end)];
           nvehicle = get_No_vehicle(nvehicle, N_of_vehicles);
       end
    end
    
    %项塍鬣屐 眍戾?已(镱耠邃钼囹咫?
    function [nvehicle] = get_No_vehicle(nvehicle, N_of_vehicles)
       nvehicle = nvehicle + 1;                
       if nvehicle > N_of_vehicles
      nvehicle = 1; %磬麒磬屐 ?1-泐 已 
       end
    end
    
    %恹麒耠屐 镳铗驽眄铖螯 怦邈?爨瘌痼蜞 潆 已
    function [ length_of_path ] = length_of_route_for_vehicles( vehicles, distances)
       length_of_path = 0;
       for k = 1:length(vehicles)
           route = vehicles(k).route;
           for i = 1:length(route) - 1
               length_of_path = length_of_path + distances(route(i),route(i + 1)); 
           end
       end
    end
    
    %恹麒耠屐 镳铗驽眄铖螯 怦邈?爨瘌痼蜞
    function [ length_of_path ] = length_of_route( route, distances)
       length_of_path = 0;
       for m = 1:length(route) - 1
          length_of_path = length_of_path + distances(route(m),route(m + 1)); 
       end
    end
    

    3 仿真结果

    4 参考文献

    [1]唐增明. 基于蚁群算法的多中心车辆调度问题研究[D]. 桂林电子科技大学, 2007.

    5 MATLAB代码与数据下载地址

    见博客主页

    展开全文
  • 完整代码,可直接运行
  • 遗传算法的matlab代码实现路径规划,栅格法画地图,障碍物位置可以自己定义,画出平均路径和最短路径曲线,适应度函数考虑路线顺滑度和距离两个因素
  • 基于蚁群算法实现路径优化matlab代码
  • 优化matlab代码轨迹6.832项目 该存储库包含用于通过TrajOpt [1]对欠驱动系统进行轨迹优化的代码,TrajOpt是一种基于顺序凸优化(SCO)的方法。 SCO通过迭代求解局部近似凸子问题来解决非凸问题。 我们使用基于...
  • 所走路程的最短路径,其可能的路径数与城市个数成指数关系增长.目前应用遗传算法解决TSP问题,主要要解决编码问题和算子的设计问题.编码方式约束了运算空间的大小,好的编码方式可以压缩求解空间,提高运算效率.常见的...
  • 蚁群算法二维路径规划,可将其与A*算法进行仿真比较。
  • 先商家后顾客的配送方式,采用遗传算法,带时间窗,有载重要求,动态外卖配送
  • 应用于路径优化问题,可实现带时间窗,或单多配送中心,载重要求等的问题优化,下载后不懂可
  • 带时间窗的粒子群算法求解车辆路径优化问题。
  • 本文件针对生鲜外卖配送优化,提出了相关简化模型,并采用遗传算法进行优化,遗传算法采用MATLAB代码编写,注释详细,可供学习
  • 尤其当各种灾害事故发生时,如何在最短的时间内找到最优化路径,并将受影响区域的人员快速疏散到安全区域成为当前的研究热点,其中最关键的是路径规划问题。近些年来,国内外专家学者对于路径规划问题的研究越来越...

    1 简介

    随着经济的持续发展和科学技术的进步,人类的各种需求日益增长,人们越来越体会到日常生活中的交通拥堵与出行的不便。尤其当各种灾害事故发生时,如何在最短的时间内找到最优化的路径,并将受影响区域的人员快速疏散到安全区域成为当前的研究热点,其中最关键的是路径规划问题。近些年来,国内外专家学者对于路径规划问题的研究越来越深入,并广泛应用于旅行商问题、机器人路径规划、车辆路径规划问题、灾后应急疏散等领域。在初期进行路径规划时,人们通常求解两点之间的最优路径,然而在现实生活中,道路网络更加复杂,道路情况更加多变,路径规划问题的种类也更多,为了更好的模拟现实,需要考虑从多个起点到多个目标点的路径规划,由此引入了多源多汇路径规划的概念。路径规划问题能否有效解决的关键在于算法的设计,蚁群算法因其自身具有的系统性、鲁棒性、正反馈性等特点,成为解决路径规划问题的有效方法。因此,论文对蚁群算法在路径规划问题中的应用着重进行了研究,重点完成了基于蚁群算法的单源最短路径问题,探索了蚁群算法用来解决多源多汇路径规划问题的可行性,并且通过进行仿真实验验证蚁群算法解决路径规划问题的可行性和收敛性。本文的主要研究内容如下:  (1)蚁群算法的参数优化设置:以中国旅行商问题(CTSP)为例,采用蚁群算法进行求解,提出了采用循环组合的枚举方式设置参数,找到最优参数组合。  (2)蚁群算法求解单源最短路径问题:参数和信息素初始化,构建解空间,引入热区搜索机制和轮盘赌策略进行节点选择,经过多次迭代产生最短路径。

    img

    img

    2 部分代码

     
    

    clear all

    close all

    C =[1 1

        2 4

        1 7

        3 1

        5 1

        5 5

        7 7

        8 3

        9 8

        9 3

        5 8

        7 1];%C n个城市的坐标,n×2的矩阵

    m=50;%蚂蚁数量

    NC_max=500;%%% NC_max 最大迭代次数

    Alpha=1;%% Alpha 表征信息素重要程度的参数

    Beta=5;%% Beta 表征启发式因子重要程度的参数

    Rho=0.5;%% Rho 信息素蒸发系数

    Q=1;%% Q 信息素增加强度系数

    %% R_best 各代最佳路线

    %% L_best 各代最佳路线的长度

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

    %%第一步:变量初始化

    n=size(C,1);%n表示问题的规模(城市个数)

    distance=100;

    D =distance.*ones(n,n);%D表示两两节点间的距离,初始设定10000,可以设定无穷大,表示不相连

    D(1,2)=3.16;%表示节点1和节点2的距离

    D(1,3)=6;

    D(1,4)=2;

    D(2,3)=3.16;

    D(2,4)=3.16;

    D(2,6)=3.16;

    D(3,11)=4.12;

    D(4,5)=2;

    D(5,12)=2;

    D(5,6)=4;

    D(5,8)=4.4;

    D(6,7)=2.82;

    D(6,11)=3;

    D(7,8)=4.1;

    D(7,9)=2.23;

    D(8,9)=1;

    D(8,10)=1;

    for   ni=1:size(C)

        for m=1:size(C)

            if D(ni,m)~=distance

                D(m,ni)=D(ni,m);   %对称矩阵

            end

        end

    end

    for startpoint=1:3

        for endpoint=9:12

            

            ACO1( C,D,m,NC_max,startpoint,endpoint,Rho,Beta,Alpha,Q,distance)

        end

    end

     
    

    3 仿真结果

    4 参考文献

    [1]张叶茂, and 杨晓武. "基于改进蚁群算法的动态路径规划算法研究." 西部交通科技 3(2017):5.

    部分理论引用网络文献,若有侵权联系博主删除。​

    展开全文
  • 面对需求网点众多,约束条件繁杂的配送情况,单纯地使用节约里程法优化物流配送路线,数据量和复杂度是非常庞大的,得到的结果并不理想会出现交叉的情况,因此添加局部优化使得路径更加合理。
  • 机器人路径规划+避障+曲线优化matlab代码 详细见: https://editor.csdn.net/md/?articleId=123592511
  • matlab取送货路径优化

    千次阅读 2021-11-04 13:05:27
    disp('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~') %% 优化 BestCost=zeros(MAXGEN,1); %记录每一代全局最优解的总成本 gen=1; while gen计算适应度 ObjV=calObj(Chrom,cusnum,cap,...

    问题描述

    假设快递集散中心负责n个配送点的快递配送任务以及包装回收,每个配送点都配备了快递柜以及快递包装回收容器,配送点工作人员在负责快递柜的投放工作以及寄件服务的同时还负责废旧包装的打包工作。快递运输车辆从快递集散中心出发向配送点配发快件并收取配送点需邮寄的快件和打包好的快递包装,快递运输车辆在完成配送任务后返回快递集散中心并卸载需邮寄的快件和打包好的快递包装,快递集散中心负责将卸载的快件向上一级配送中心邮寄并把回收的快递包装整合交给废旧包装回收公司。

    体积25 立方米
    百公里油耗60元/9.5L/6.65kg
    燃油二氧化碳排放系数3.1705 kg-co2/kg
    碳税10元/吨
    车辆平均行驶速度40km/h
    包装回收载货空间0.1立方米
    快递存放载货空间3.4立方米
    单位快递容积0.027立方米
    单位快递包装容积0.0008立方米
    固定成本18.6元/辆*天

    符号说明

    在这里插入图片描述
    在这里插入图片描述

    模型假设

    假设1:快递包装为标准规格包装;
    假设2:不考虑不同路面及交通延误对配送方案的影响;
    假设3:配送车辆均为标准规格的快递配送车;
    假设4:不考虑各配送点的时间窗约束;
    假设5:各配送点均自行负责回收的快递包装打包工作,因此配送方案不考虑回收的快递包装打包产生的人工费用,
    模型建立
    在这里插入图片描述
    假设某一快递配送中心为27个配送点配送和收取快递同时收取废旧包装[13],各配送点及配送中心的位置和货物信息如下表所示;运送的快件多为4号标准规格的包装,即360×300×250MM规格包装,因此本文将所有快件都视为此规格的快件,回收的包装材料也打包为同等规格的包装,具体参数如下表所示。

    客户横坐标纵坐标配送量/件取件量/件回收量/件
    01111000
    14610160130148
    21629260270214
    318710012589
    41343400333389
    51339120112105
    61930160185152
    7136120157111
    8277200226187
    9324350433326
    10205650467614
    113835180118163
    125012240130227
    133730420222396
    142048420400374
    152131180109152
    161415120235112
    171140400406388
    184227270238259
    195049200124187
    2021238010669
    21823220150205
    22275240160215
    234117360305317
    241431280229265
    251150280151269
    261811150109148
    273142500640492
    车型百公里燃油消耗容量平均使用年限购置税
    轻型卡车60元25立方米854270元

    在这里插入图片描述
    在这里插入图片描述

    
    tic
    clear
    clc
    %% 用importdata这个函数来读取文件 
    load('data1');
    cap=25;
    %% 提取数据信息
    vertexs=data(:,2:3);                %所有点的坐标x和y
    customer=vertexs(2:end,:);          %顾客坐标
    cusnum=size(customer,1);            %顾客数
    v_num=16;                           %初始车辆使用数目
    demands=data(2:end,4);              %需求量
    qujian=data(2:end,5);%取件量
    huishou=data(2:end,5);%回收量
    h=pdist(vertexs);
    dist=squareform(h);                 %距离矩阵
    %% 遗传算法参数设置
    alpha=1000;                                                       %违反的容量约束的惩罚函数系数
    NIND=200;                                                        %种群大小
    MAXGEN=1000;                                                     %迭代次数
    Pc=0.9;                                                         %交叉概率
    Pm=0.05;                                                        %变异概率
    GGAP=0.9;                                                       %代沟(Generation gap)
    N=cusnum+v_num-1;                                               %染色体长度=顾客数目+车辆最多使用数目-1
    %% 种群初始化
    Chrom=InitPop(NIND,N);
    %% 输出随机解的路线和总距离
    disp('初始种群中的一个随机值:')
    [currVC,NV,TD]=decode(Chrom(1,:),cusnum,cap,demands,dist);       %对初始解解码
    currCost=costFuction(currVC,dist,demands,cap,alpha,NV,qujian,huishou);        %求初始配送方案的成本=车辆行驶总成本+alpha*违反的容量约束之和
    disp(['车辆使用数目:',num2str(NV),',车辆行驶总距离:',num2str(TD)]);
    disp('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~')
    %% 优化
    BestCost=zeros(MAXGEN,1);       %记录每一代全局最优解的总成本
    gen=1;
    while gen<=MAXGEN
        %% 计算适应度
        ObjV=calObj(Chrom,cusnum,cap,demands,dist,alpha,qujian,huishou);                           %计算种群目标函数值
        FitnV=Fitness(ObjV);
        %% 选择
        SelCh=Select(Chrom,FitnV,GGAP);
        %% OX交叉操作
        SelCh=Recombin(SelCh,Pc);
        %% 变异
        SelCh=Mutate(SelCh,Pm);
        %% 局部搜索操作
    %     SelCh=LocalSearch(SelCh,cusnum,cap,demands,dist,alpha,qujian,huishou);
        %% 重插入子代的新种群
        Chrom=Reins(Chrom,SelCh,ObjV);
    %     %% 删除种群中重复个体,并补齐删除的个体
    %     Chrom=deal_Repeat(Chrom);
        %% 打印当前最优解
        ObjV=calObj(Chrom,cusnum,cap,demands,dist,alpha,qujian,huishou);                           %计算种群目标函数值
        [minObjV,minInd]=min(ObjV);
        BestCost(gen)=minObjV;
        disp(['第',num2str(gen),'代最优解:'])
        [bestVC,bestNV,bestTD]=decode(Chrom(minInd(1),:),cusnum,cap,demands,dist);
        disp(['车辆使用数目:',num2str(bestNV),',车辆行驶总距离:',num2str(bestTD)]);
        fprintf('\n')
        %% 更新迭代次数
        gen=gen+1 ;
    end
    %% 打印外层循环每次迭代的全局最优解的总成本变化趋势图
    figure;
    plot(BestCost,'LineWidth',1);
    title('全局最优解的总成本变化趋势图')
    xlabel('迭代次数');
    ylabel('总成本');
    %% 打印全局最优解路线图
    draw_Best(bestVC,vertexs);
    toc
    VX:zhangshu2274
    
    展开全文
  • 基于Matlab物流配送路径优化问题遗传算法的实现.pdf
  • 灰狼优化算法(GWO)matlab代码
  • 通过该模型求解带软时间窗的vrptw模型,得到车辆路径问题的最优解
  • 基于CVaR的危险品多式联运风险评价问题,考虑到不同运输方式的道路运输风险,以及在运输...模型可以为政府、危险品运输商提供一条基于CVaR最优的危险品多式联运运输道路,为现实生活中的路径规划、路线选择提供参考.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,335
精华内容 4,134
关键字:

路径优化matlab代码

matlab 订阅