【机器人栅格地图】基于鲸鱼算法WOA实现机器人栅格地图路径规划，目标函数：最短距离附Matlab代码

鲸鱼优化算法（Whale Optimization Algorithm, WOA）是一种基于鲸鱼觅食行为的优化算法，可以用于解决路径规划问题。下面是一个基于鲸鱼优化算法实现机器人栅格地图路径规划的Matlab代码示例，目标函数是最短距离。

function woa_path_planning()
% Parameters
grid_size = 10; % Size of the grid (10x10)
num_iterations = 100; % Number of iterations
num_whales = 20; % Number of whales (population size)
a = 2; % Coefficient for shrinking encircling mechanism
b = 1; % Coefficient for logarithmic spiral shape
p = 0.5; % Probability of selecting bubble-net attack or search prey

% Initialize the grid with obstacles (1 = obstacle, 0 = free space)
grid = zeros(grid_size);
grid(3, 5) = 1; % Example obstacle
grid(7, 8) = 1; % Example obstacle

% Start and end points
start_point = [1, 1]; % Top-left corner
end_point = [grid_size, grid_size]; % Bottom-right corner

% Initialize whale positions (random paths)
whales = initialize_whales(grid_size, num_whales, start_point, end_point);

% Calculate initial distances
distances = calculate_distances(whales, grid, start_point, end_point);

% Best solution found so far
[best_distance, best_index] = min(distances);
best_path = whales{best_index};

%鲸鱼优化算法主循环
for iter = 1:num_iterations
    for i = 1:num_whales
        % Update whale position using WOA mechanisms
        if rand < p
            % Bubble-net attack
            whales{i} = bubble_net_attack(whales{i}, best_path, a, b, grid, start_point, end_point);
        else
            % Search prey
            whales{i} = search_prey(whales{i}, grid, start_point, end_point);
        end

        % Ensure the new path does not collide with obstacles
        whales{i} = avoid_obstacles(whales{i}, grid);

        % Calculate the new distance
        new_distance = calculate_distance(whales{i}, grid, start_point, end_point);

        % Accept the new position if it's better
        if new_distance < distances(i)
            distances(i) = new_distance;
            whales{i} = ensure_valid_path(whales{i}, grid, start_point, end_point);

            % Update the best solution if necessary
            if new_distance < best_distance
                best_distance = new_distance;
                best_path = whales{i};
            end
        end
    end

    % Display the best path and its distance every 10 iterations
    if mod(iter, 10) == 0
        disp(['Iteration ' num2str(iter) ': Best Distance = ' num2str(best_distance)]);
        visualize_path(grid, best_path);
    end
end

% Display the final best path and its distance
disp(['Final Best Distance = ' num2str(best_distance)]);
visualize_path(grid, best_path);

end

function whales = initialize_whales(grid_size, num_whales, start_point, end_point)
whales = cell(num_whales, 1);
for i = 1:num_whales
path = zeros(1, grid_size * 2 - 1); % Path length from start to end
path(1) = start_point(1);
path(end) = end_point(1);

    % Random intermediate points
    for j = 2:(length(path)-1)
        path(j) = randi([start_point(1) end_point(1)]);
    end
    
    % Ensure the path is continuous and valid
    path = ensure_valid_path(path, zeros(grid_size), start_point, end_point);
    whales{i} = path;
end

end

function new_path = bubble_net_attack(current_path, best_path, a, b, grid, start_point, end_point)
% Placeholder for bubble-net attack mechanism
% Here we simplify it by adding a small random perturbation to the best path
new_path = current_path + (best_path - current_path) * rand * a * (1 - b * log(rand));
new_path = round(new_path); % Round to nearest grid points
new_path = ensure_valid_path(new_path, grid, start_point, end_point);
end

function new_path = search_prey(current_path, grid, start_point, end_point)
% Placeholder for search prey mechanism
% Here we simplify it by adding a random direction to the current path
direction = randn(1, length(current_path) - 1) * 2 - 1; % Random direction
new_path = current_path + direction;
new_path = round(new_path); % Round to nearest grid points
new_path = ensure_valid_path(new_path, grid, start_point, end_point);
end

function distance = calculate_distance(path, grid, start_point, end_point)
% Calculate the Euclidean distance of the path (ignoring obstacles for simplicity)
% This is a placeholder; in a real scenario, you should use a pathfinding algorithm
% to calculate the actual traversable distance
distance = sum(abs(diff(path))); % Simplified as Manhattan distance for this example
end

function distances = calculate_distances(whales, grid, start_point, end_point)
distances = zeros(length(whales), 1);
for i = 1:length(whales)
distances(i) = calculate_distance(whales{i}, grid, start_point, end_point);
end
end

function path = ensure_valid_path(path, grid, start_point, end_point)
% Ensure the path is valid (i.e., does not go through obstacles)
% Placeholder for a more sophisticated path validation algorithm
% Here we simplify it by skipping obstacles (not a realistic approach)
valid_path = true(1, length(path));
for i = 2:length(path)-1
if grid(round(path(i)), round(path(i+1)-path(i-1)/2+path(i-1))) == 1 % Simplified check for obstacles
valid_path(i:i+1) = false;
end
end

% Simple fix: Replace invalid parts with a straight line
new_path = zeros(1, length(path));
new_path(1) = start_point(1);
k = 2;
for i = 2:length(path)-1
    if valid_path(i)
        new_path(k) = path(i);
        k = k + 1;
    end
end
new_path(k) = end_point(1);

% Interpolate missing points (simple linear interpolation for this example)
path_length = length(new_path) - 1;
if path_length < length(path) - 1
    for i = 2:path_length+1
        diff_x = new_path(i) - new_path(i-1);
        num_steps = round((length(path) - length(new_path)) / (path_length));
        for j = 1:num_steps
            insert_index = (i-1)*num_steps + j;
            if insert_index > length(path)
                break;
            end
            new_path = [new_path(1:insert_index-1), new_path(i-1) + diff_x * j / num_steps, new_path(insert_index:end)];
        end
    end
end

path = new_path(1:length(path)); % Ensure final path length matches original

end

function path = avoid_obstacles(path, grid)
% Placeholder function to avoid obstacles
% This is a very simplistic approach and should be replaced with a more sophisticated algorithm
for i = 2:length(path)-1
if grid(round(path(i)), round(path(i