用遗传算法编写多辆AGV小车路径规划问题的matlab代码

以下是一个简单的遗传算法编写多辆AGV小车路径规划问题的matlab代码：

% 遗传算法参数设置
pop_size = 100; % 种群大小
num_gen = 100; % 迭代次数
cross_prob = 0.8; % 交叉概率
mut_prob = 0.05; % 变异概率

% 地图信息
map_size = 20; % 地图大小
num_agvs = 3; % 小车数量
start_pos = [1,1;3,1;5,1]; % 小车起始位置
target_pos = [10,10;15,10;18,10]; % 小车目标位置
obstacle_pos = [2,5;3,5;4,5;5,5;6,5;7,5;8,5;9,5;10,5]; % 障碍物位置

% 生成初始种群
pop = init_pop(pop_size, num_agvs, start_pos, target_pos, obstacle_pos, map_size);

for i=1:num_gen
    % 计算适应度函数
    fit = calc_fitness(pop);
    
    % 选择
    parents = select_parents(pop, fit);
    
    % 交叉
    offspring = crossover(parents, cross_prob);
    
    % 变异
    offspring = mutation(offspring, mut_prob, map_size);
    
    % 合并种群
    pop = [pop; offspring];
    
    % 筛选
    pop = select_population(pop, pop_size, fit);
end

% 打印最优解
[min_fit, min_idx] = min(fit);
disp(['最优解: ', num2str(min_fit)]);
disp(['路径规划: ', num2str(pop(min_idx,:))]);

% 初始化种群
function pop = init_pop(pop_size, num_agvs, start_pos, target_pos, obstacle_pos, map_size)
    pop = zeros(pop_size, num_agvs*2);
    for i=1:pop_size
        for j=1:num_agvs
            % 随机生成路径规划
            path = randi([-1,1], [1, map_size-1]);
            path(path==0) = 1;
            pop(i,(j-1)*2+1:j*2) = [start_pos(j,:), path];
        end
    end
end

% 计算适应度函数
function fit = calc_fitness(pop)
    [pop_size, ~] = size(pop);
    fit = zeros(1, pop_size);
    for i=1:pop_size
        % 计算每个小车的路径长度
        dist = zeros(1, num_agvs);
        for j=1:num_agvs
            path = pop(i,(j-1)*2+3:j*2+1);
            path = path(path~=0);
            pos = pop(i,(j-1)*2+1:j*2);
            for k=1:length(path)
                if path(k) == -1
                    pos(1) = pos(1) - 1;
                elseif path(k) == 1
                    pos(1) = pos(1) + 1;
                elseif path(k) == -2
                    pos(2) = pos(2) - 1;
                elseif path(k) == 2
                    pos(2) = pos(2) + 1;
                end
                % 判断是否到达目标位置
                if pos(1)==target_pos(j,1) && pos(2)==target_pos(j,2)
                    break;
                end
            end
            dist(j) = length(path);
        end
        fit(i) = sum(dist);
    end
end

% 选择
function parents = select_parents(pop, fit)
    [pop_size, ~] = size(pop);
    parents = zeros(pop_size, num_agvs*2);
    for i=1:pop_size
        % 轮盘赌选择
        idx1 = randi([1,pop_size]);
        idx2 = randi([1,pop_size]);
        if fit(idx1) < fit(idx2)
            parents(i,:) = pop(idx1,:);
        else
            parents(i,:) = pop(idx2,:);
        end
    end
end

% 交叉
function offspring = crossover(parents, cross_prob)
    [pop_size, ~] = size(parents);
    offspring = zeros(pop_size, num_agvs*2);
    for i=1:2:pop_size
        % 随机选择两个个体进行交叉
        if rand() <= cross_prob
            idx1 = randi([1,pop_size]);
            idx2 = randi([1,pop_size]);
            parent1 = parents(idx1,:);
            parent2 = parents(idx2,:);
            % 随机选择交叉点
            cross_point = randi([1,num_agvs*2-1]);
            offspring(i,:) = [parent1(1:cross_point), parent2(cross_point+1:end)];
            offspring(i+1,:) = [parent2(1:cross_point), parent1(cross_point+1:end)];
        else
            offspring(i,:) = parents(i,:);
            offspring(i+1,:) = parents(i+1,:);
        end
    end
end

% 变异
function offspring = mutation(offspring, mut_prob, map_size)
    [pop_size, ~] = size(offspring);
    for i=1:pop_size
        for j=1:num_agvs
            % 随机选择变异点
            if rand() <= mut_prob
                mut_point = randi([3,map_size+1]);
                path = offspring(i,(j-1)*2+3:j*2+1);
                % 随机变异
                rand_val = randi([-1,1]);
                if rand_val == 0
                    rand_val = 1;
                end
                path(mut_point-2) = rand_val;
                offspring(i,(j-1)*2+3:j*2+1) = path;
            end
        end
    end
end

% 筛选
function pop = select_population(pop, pop_size, fit)
    [~, idx] = sort(fit);
    pop = pop(idx(1:pop_size),:);
end

这个代码实现了一个简单的多辆AGV小车路径规划问题的遗传算法。在这个问题中，我们需要规划每个小车从起始位置到目标位置的路径，并且路径不能穿过障碍物。我们使用遗传算法来优化路径规划，其中每个个体表示一组路径规划方案。遗传算法的迭代过程中，我们计算每个个体的适应度函数，然后进行选择、交叉和变异操作。最终得到的最优解是一组最短路径规划方案。