基于分支定界算法的TSP MATLAB脚本整合与迭代改造问询

Hey there! Let's break down how to tackle your two main goals: integrating your two MATLAB scripts and converting the whole thing to run iteratively. Here's a step-by-step approach tailored to your setup:

First, we'll turn your generate_distance_matrix script into a reusable function, so your main TSP solver can easily switch between hardcoded test data and Excel-loaded coordinates.

Step 1: Refactor generate_distance_matrix into a Function #

Rename your existing script file to generate_distance_matrix.m and rewrite it as a parameterized function that returns a distance matrix:

function distance_matrix = generate_distance_matrix(excel_filename)
    % Load city coordinates from Excel (assumes columns named 'x1' and 'x2')
    city_data = readtable(excel_filename);
    coords = [city_data.x1, city_data.x2];
    num_cities = size(coords, 1);
    
    % Initialize distance matrix
    distance_matrix = zeros(num_cities, num_cities);
    
    % Calculate Euclidean distance between all city pairs
    for i = 1:num_cities
        for j = 1:num_cities
            if i ~= j
                distance_matrix(i,j) = norm(coords(i,:) - coords(j,:));
            end
        end
    end
end

Step 2: Update Your Main TSP Script to Use Both Data Sources #

Modify your branch-and-bound TSP script to let you choose between the hardcoded A/B/C/D test case and Excel-loaded data:

% Main TSP Branch-and-Bound Solver
clear; clc;

% Let user select data source
disp('Select data source:');
disp('1. Test with A/B/C/D cities (hardcoded matrix)');
disp('2. Load from Test.xlsx');
choice = input('Enter your choice (1/2): ');

% Load or define distance matrix
if choice == 1
    % Hardcoded matrix for cities A(1), B(2), C(3), D(4)
    distance_matrix = [0 2 5 7;
                       2 0 8 3;
                       5 8 0 1;
                       7 3 1 0];
    city_labels = {'A', 'B', 'C', 'D'}; % For readable output
elseif choice == 2
    % Call our new function to generate matrix from Excel
    distance_matrix = generate_distance_matrix('Test.xlsx');
    num_cities = size(distance_matrix, 1);
    city_labels = cellstr(num2str((1:num_cities)', 'City %d')); % Default labels
else
    error('Invalid choice! Please enter 1 or 2.');
end

% Insert your existing branch-and-bound TSP logic here
% Example placeholder:
% [best_route, best_distance] = tsp_branch_and_bound(distance_matrix);
% disp('Optimal Route:'); disp(city_labels(best_route));
% disp(['Total Distance: ', num2str(best_distance)]);

Iterative running usually means repeating the solver for multiple inputs or parameter sets. Here are two common use cases:

2.1 Iterate Over Multiple Data Sources #

If you want to run the solver for multiple Excel files or test cases, wrap everything in a loop with a list of input sources:

% Iterative TSP Solver for Multiple Inputs
clear; clc;

% Define all input sources (mix hardcoded and Excel files)
input_sources = {
    struct('type', 'hardcoded', 'matrix', [0 2 5 7; 2 0 8 3; 5 8 0 1; 7 3 1 0], 'labels', {'A','B','C','D'}),
    struct('type', 'excel', 'file', 'Test.xlsx'),
    struct('type', 'excel', 'file', 'Another_Test_Set.xlsx') % Add more as needed
};

% Loop through each input source
for idx = 1:length(input_sources)
    disp(['=== Running TSP for Input ', num2str(idx), ' ===']);
    current_source = input_sources{idx};
    
    % Load distance matrix
    if strcmp(current_source.type, 'hardcoded')
        distance_matrix = current_source.matrix;
        city_labels = current_source.labels;
    else
        distance_matrix = generate_distance_matrix(current_source.file);
        num_cities = size(distance_matrix, 1);
        city_labels = cellstr(num2str((1:num_cities)', 'City %d'));
    end
    
    % Run your branch-and-bound solver
    % [best_route, best_distance] = tsp_branch_and_bound(distance_matrix);
    
    % Print results
    % disp('Optimal Route:'); disp(city_labels(best_route));
    % disp(['Total Distance: ', num2str(best_distance)]);
    disp('----------------------------------------');
end

2.2 Iterate with Parameter Tuning (Optional) #

If you want to test different branch-and-bound settings (like lower-bound methods or timeouts), loop through parameter sets:

% Iterative Solver with Parameter Testing
clear; clc;

% Load base distance matrix
distance_matrix = generate_distance_matrix('Test.xlsx');
city_labels = cellstr(num2str((1:size(distance_matrix,1))', 'City %d'));

% Define parameter sets to test
parameter_sets = {
    struct('lower_bound', 'nearest_neighbor', 'timeout', 60),
    struct('lower_bound', 'minimum_spanning_tree', 'timeout', 120)
};

% Test each parameter set
for idx = 1:length(parameter_sets)
    params = parameter_sets{idx};
    disp(['=== Testing Parameter Set ', num2str(idx), ' ===']);
    disp(['Lower Bound Method: ', params.lower_bound, ' | Timeout: ', num2str(params.timeout), 's']);
    
    % Pass parameters to your solver
    % [best_route, best_distance, runtime] = tsp_branch_and_bound(distance_matrix, params);
    
    % Print results
    % disp('Optimal Route:'); disp(city_labels(best_route));
    % disp(['Total Distance: ', num2str(best_distance), ' | Runtime: ', num2str(runtime), 's']);
    disp('----------------------------------------');
end

Quick Tips #

• Modularize Your Solver: Turn your existing branch-and-bound code into a function (e.g., tsp_branch_and_bound.m) that takes a distance matrix (and optional parameters) and returns the best route/distance. This makes iterative calls way cleaner.
• Error Handling: Add checks for Excel file existence or valid coordinate data to avoid crashes during iterative runs.

内容的提问来源于stack exchange，提问作者stefx