用matlab生成一个网络拓扑结构，计算网络初始拓扑效率，计算效率时不要使用内置函数，然后随机攻击网络中的若干节点，采用遗传算法找到能使网络效率恢复最快的节点修复顺序，给出代码，并输出最优修复策略的节点修复顺序，并使网络效率结果可视化

生成网络拓扑结构的代码：

N = 10; % 网络节点数
p = 0.2; % 网络连接概率

% 生成随机网络拓扑
adj_matrix = rand(N) < p;
adj_matrix = triu(adj_matrix, 1); % 上三角矩阵，去掉对角线及下三角部分
adj_matrix = adj_matrix + adj_matrix'; % 对称矩阵

计算网络初始拓扑效率的代码：

% 计算每个节点到其他节点的最短路径
dist = zeros(N); % 距离矩阵
for i = 1:N
    for j = i+1:N
        if adj_matrix(i,j) == 1 % 有连接
            dist(i,j) = 1;
            dist(j,i) = 1;
        else % 无连接
            dist(i,j) = inf;
            dist(j,i) = inf;
        end
    end
end
for k = 1:N
    for i = 1:N
        for j = 1:N
            if dist(i,k) + dist(k,j) < dist(i,j)
                dist(i,j) = dist(i,k) + dist(k,j);
            end
        end
    end
end

% 计算网络初始拓扑效率
efficiency = 0;
for i = 1:N
    for j = i+1:N
        if dist(i,j) ~= inf
            efficiency = efficiency + 1/dist(i,j);
        end
    end
end
efficiency = 2*efficiency/(N*(N-1));

随机攻击网络中的若干节点的代码：

% 随机选择一些节点进行攻击
num_attacks = 3; % 攻击节点数
attack_nodes = randperm(N, num_attacks);

% 将被攻击节点从网络中删除
adj_matrix(attack_nodes,:) = 0;
adj_matrix(:,attack_nodes) = 0;

遗传算法优化节点修复顺序的代码：

% 适应度函数：计算修复节点顺序的效率
function efficiency = repair_fitness(attack_nodes, repair_order, adj_matrix)
    N = length(adj_matrix);
    
    % 恢复被攻击节点
    for i = repair_order
        adj_matrix(i,:) = 0;
        adj_matrix(:,i) = 0;
    end
    
    % 计算每个节点到其他节点的最短路径
    dist = zeros(N); % 距离矩阵
    for i = 1:N
        for j = i+1:N
            if adj_matrix(i,j) == 1 % 有连接
                dist(i,j) = 1;
                dist(j,i) = 1;
            else % 无连接
                dist(i,j) = inf;
                dist(j,i) = inf;
            end
        end
    end
    for k = 1:N
        for i = 1:N
            for j = 1:N
                if dist(i,k) + dist(k,j) < dist(i,j)
                    dist(i,j) = dist(i,k) + dist(k,j);
                end
            end
        end
    end
    
    % 计算网络恢复后的拓扑效率
    efficiency = 0;
    for i = 1:N
        for j = i+1:N
            if dist(i,j) ~= inf
                efficiency = efficiency + 1/dist(i,j);
            end
        end
    end
    efficiency = 2*efficiency/(N*(N-1));
end

% 遗传算法参数设置
pop_size = 20; % 种群大小
num_generations = 50; % 迭代次数
mutation_prob = 0.1; % 变异概率

% 初始化种群
pop = zeros(pop_size, num_attacks); % 种群矩阵
for i = 1:pop_size
    pop(i,:) = randperm(num_attacks);
end

% 迭代优化
for generation = 1:num_generations
    % 计算种群适应度
    fitness = zeros(pop_size, 1);
    for i = 1:pop_size
        fitness(i) = repair_fitness(attack_nodes, pop(i,:), adj_matrix);
    end
    
    % 选择
    [sorted_fitness, idx] = sort(fitness, 'descend');
    elite = pop(idx(1:2),:); % 精英个体
    pop = elite; % 保留精英
    
    % 交叉
    for i = 3:pop_size
        p1 = randi([1 pop_size], 1);
        p2 = randi([1 pop_size], 1);
        child = zeros(1, num_attacks);
        for j = 1:num_attacks
            if rand() < 0.5
                child(j) = pop(p1,j);
            else
                child(j) = pop(p2,j);
            end
        end
        pop(i,:) = child;
    end
    
    % 变异
    for i = 2:pop_size
        if rand() < mutation_prob
            idx1 = randi([1 num_attacks], 1);
            idx2 = randi([1 num_attacks], 1);
            pop(i,[idx1 idx2]) = pop(i,[idx2 idx1]); % 交换位置
        end
    end
end

% 找到最优解
best_fitness = 0;
best_repair_order = [];
for i = 1:pop_size
    fitness = repair_fitness(attack_nodes, pop(i,:), adj_matrix);
    if fitness > best_fitness
        best_fitness = fitness;
        best_repair_order = pop(i,:);
    end
end

输出最优修复策略的节点修复顺序的代码：

fprintf('最优修复策略的节点修复顺序：');
disp(attack_nodes(best_repair_order));

使网络效率结果可视化的代码：

% 恢复被攻击节点
for i = attack_nodes(best_repair_order)
    adj_matrix(i,:) = 0;
    adj_matrix(:,i) = 0;
end

% 计算每个节点到其他节点的最短路径
dist = zeros(N); % 距离矩阵
for i = 1:N
    for j = i+1:N
        if adj_matrix(i,j) == 1 % 有连接
            dist(i,j) = 1;
            dist(j,i) = 1;
        else % 无连接
            dist(i,j) = inf;
            dist(j,i) = inf;
        end
    end
end
for k = 1:N
    for i = 1:N
        for j = 1:N
            if dist(i,k) + dist(k,j) < dist(i,j)
                dist(i,j) = dist(i,k) + dist(k,j);
            end
        end
    end
end

% 计算网络恢复后的拓扑效率
efficiency = 0;
for i = 1:N
    for j = i+1:N
        if dist(i,j) ~= inf
            efficiency = efficiency + 1/dist(i,j);
        end
    end
end
efficiency = 2*efficiency/(N*(N-1));

% 可视化网络拓扑
G = graph(adj_matrix);
figure();
plot(G, 'Layout', 'force');
title(['网络拓扑（效率：' num2str(efficiency) '）']);