基于蚁群算法的路径规划

蚁群算法是一种模拟自然界蚂蚁寻找食物过程中选择路径的优化算法，常用于解决路径规划问题。蚂蚁在寻找食物的过程中，会根据路径上食物的丰富程度和障碍物的多少来选择最优路径。通过模拟这种行为，蚁群算法可以在一些复杂的、带有噪声的、受限制的环境中进行全局优化搜索，找到最短或最优的路径。

基于蚁群算法的路径规划主要步骤包括：

1. 初始化：设定蚂蚁数量、信息素挥发系数、启发因子初始值等参数。
2. 蚂蚁按照算法规则选择下一个节点，并在选择的路径上增加信息素浓度。
3. 根据信息素的挥发和路径长度等信息，更新所有蚂蚁的路径选择概率。
4. 收集信息素并重新分配到各条路径上，更新路径信息素浓度。
5. 重复步骤2-4，直到满足终止条件（如迭代次数达到预设值，或找到满足要求的路径）。

蚁群算法在路径规划中的应用优势在于其全局优化能力和对复杂环境的适应性。然而，它也受到一些限制，如对于较小的环境或者封闭环境，算法可能会陷入局部最优解，因此在具体应用中需要结合实际问题进行算法调整和改进。此外，蚁群算法对初始条件的敏感度较高，可能对不同初始分布的路径集合产生不同的搜索效果。

基于蚁群算法的路径规划在许多领域都有应用，如机器人导航、无人机配送、无人驾驶汽车、管道铺设等。这些应用场景中，都需要找到最优或次优的路径以降低能耗、提高效率或保证安全。因此，蚁群算法作为一种启发式的优化方法，在解决这些问题上具有很大的潜力。

本文就初始路径通过蚁群算法进行优化。

代码如下：

clc
clear
% 参数设置
num_ants = 50; % 蚂蚁数量
num_iterations = 100; % 迭代次数
alpha = 1; % 信息素重要性因子
beta = 5; % 启发式信息重要性因子
rho = 0.1; % 信息素挥发系数
Q = 1; % 信息素常量

% 客户点数据（20个客户，其中部分有时间窗口限制）
locations = [
    0 0; 2 3; 5 5; 6 8; 8 8; 7 6; 3 2; 4 4; 5 3; 7 7;
    1 6; 2 8; 6 4; 3 7; 5 1; 6 2; 4 5; 8 3;  
]; % 包括配送中心
time_windows = [
    0 1440; 480 600; 540 720; 600 780; 660 840; 720 900; 0 1440; 0 1440; 0 1440; 0 1440;
    0 1440; 0 1440; 0 1440; 0 1440; 0 1440; 0 1440; 0 1440; 0 1440; 
]; % 时间窗口 (分钟)，其中部分客户没有时间窗口
n = size(locations, 1) - 1; % 客户点数量
speed = 1; % 行驶速度 (单位距离/分钟)

% 计算距离矩阵
distances = zeros(n+1, n+1);
for i = 1:n+1
    for j = 1:n+1
        distances(i, j) = norm(locations(i, :) - locations(j, :));
    end
end

% 初始化信息素矩阵
pheromone = ones(n+1, n+1);

% 初始化最优路径和距离
best_distance = inf;
best_route = [];

% 初始路径和时间计算（假设一个初始路径）
initial_route = 1:n+1; % 例如 [1 2 3 ... 20 1]
initial_route(end) = 1; % 返回配送中心
initial_time = 0;
for i = 1:length(initial_route)-1
    initial_time = initial_time + distances(initial_route(i), initial_route(i+1)) / speed;
end

% 可视化初始路径
figure;
plot(locations(initial_route, 1), locations(initial_route, 2), '-*');
title('初始路径');
xlabel('X 坐标');
ylabel('Y 坐标');
grid on;

for iter = 1:num_iterations
    routes = zeros(num_ants, n+1);
    route_lengths = zeros(num_ants, 1);
    
    for k = 1:num_ants
        visited = zeros(1, n+1);
        route = zeros(1, n+1);
        current_node = 1; % 从配送中心开始
        visited(current_node) = 1;
        route(1) = current_node;
        current_time = 0;
        
        for step = 2:n+1
            probabilities = calculate_probabilities(current_node, visited, distances, pheromone, alpha, beta);
            next_node = roulette_wheel_selection(probabilities);
            if next_node == -1
                break;
            end
            route(step) = next_node;
            visited(next_node) = 1;
            travel_time = distances(current_node, next_node) / speed;
            current_time = max(current_time + travel_time, time_windows(next_node, 1));
            if current_time > time_windows(next_node, 2)
                break;
            end
            current_node = next_node;
        end
        
        % 补全未访问的节点（如果有）
        unvisited = find(visited == 0);
        if ~isempty(unvisited)
            route(step:step+length(unvisited)-1) = unvisited;
            step = step + length(unvisited);
        end
        
        % 确保路径返回配送中心
        route(end) = 1;
        
        % 计算路径长度
        route_length = 0;
        for i = 1:n
            if route(i+1) > 0
                route_length = route_length + distances(route(i), route(i+1));
            end
        end
        route_length = route_length + distances(route(n+1), 1); % 返回配送中心
        routes(k, :) = route;
        route_lengths(k) = route_length;
        
        % 更新最优解
        if route_length < best_distance
            best_distance = route_length;
            best_route = route;
        end
    end
    
    % 更新信息素
    pheromone = (1 - rho) * pheromone;
    for k = 1:num_ants
        for i = 1:n
            if routes(k, i+1) > 0
                pheromone(routes(k, i), routes(k, i+1)) = pheromone(routes(k, i), routes(k, i+1)) + Q / route_lengths(k);
            end
        end
    end
    
    fprintf('Iteration %d, Best Distance: %.2f\n', iter, best_distance);
end

% 计算最终路径的总时间
final_time = 0;
for i = 1:length(best_route)-1
    final_time = final_time + distances(best_route(i), best_route(i+1)) / speed;
end

% 输出最优路径和最优距离
disp('最佳路线:');
disp(best_route);
fprintf('最短时间: %.2f\n', best_distance);

% 输出初始和最终路径的总时间
fprintf('初始总时间: %.2f min\n', initial_time);
fprintf('最终总时间: %.2f min\n', final_time);

% 可视化最终优化路径
figure;
plot(locations(best_route, 1), locations(best_route, 2), '-*');
title('最终优化路径');
xlabel('X 坐标');
ylabel('Y 坐标');
grid on;

% 计算概率的函数
function probabilities = calculate_probabilities(current_node, visited, distances, pheromone, alpha, beta)
    n = length(visited) - 1;
    probabilities = zeros(1, n+1);
    
    for j = 1:n+1
        if ~visited(j)
            probabilities(j) = (pheromone(current_node, j)^alpha) * ((1 / distances(current_node, j))^beta);
        end
    end
    
    sum_probabilities = sum(probabilities);
    if sum_probabilities == 0
        probabilities = -1 * ones(1, n+1);
    else
        probabilities = probabilities / sum_probabilities;
    end
end

% 轮盘赌选择下一个节点的函数
function next_node = roulette_wheel_selection(probabilities)
    if probabilities(1) == -1
        next_node = -1;
        return;
    end
    
    cumulative_probabilities = cumsum(probabilities);
    r = rand();
    next_node = find(cumulative_probabilities >= r, 1);
end