简化版天鹰优化算法（HHO）

天鹰优化算法（Harris Hawk Optimization, HHO）是一种基于群体的优化算法，由Seyedali Mirjalili教授于2019年提出。这种算法的灵感来源于哈里斯鹰（Harris's Hawk）的社会行为和捕猎技巧。哈里斯鹰是一种非常聪明且具有高度社会性的猛禽，它们通常会成群结队地追捕猎物，通过协同合作来提高捕猎的成功率。

在HHO算法中，解空间中的每个潜在解决方案被视为一个“鹰”，而整个解空间则被模拟为一个捕猎场景。算法的主要思想是模拟鹰群在捕猎过程中的追逐、包围和攻击猎物的行为。这些行为在算法中被转化为数学模型，用于更新鹰群的位置，从而在搜索空间中寻找最优解。

HHO算法的主要特点包括：

群体智能：算法利用群体协作的特性，模拟鹰群的社会行为来搜索全局最优解。
自适应：算法中的参数（如速度和位置）会根据搜索过程中的反馈进行自适应调整。
简单高效：算法的规则相对简单，易于实现，且通常能够在较少的迭代次数内找到解。
HHO算法的基本步骤如下：

初始化：随机生成初始种群（鹰群），并计算每个个体的适应度。
迭代过程：在每次迭代中，根据鹰群的社会行为更新每个鹰的位置。
更新策略：根据鹰与猎物之间的相互作用，更新鹰的速度和位置。
领导者更新：如果新的位置提供了更好的适应度，更新领导者的位置。
终止条件：当达到预定的迭代次数或适应度满足特定条件时，算法终止。

简化版天鹰优化算法（HHO） C++实现

#include <iostream>
#include <vector>
#include <cmath>
#include <random>
#include <numeric>
#include <limits>

// 球面函数作为适应度函数
double sphere_fitness(const std::vector<double>& x) {
    return std::accumulate(x.begin(), x.end(), 0.0, [](double sum, double val) {
        return sum + val * val;
    });
}

void hho(std::vector<double>& best_position, int dim, int pop_size, int max_iter) {
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> dis(-5.12, 5.12);

    std::vector<std::vector<double>> population(pop_size, std::vector<double>(dim));
    std::vector<double> fitness_values(pop_size);
    std::vector<double> best_solution(dim);

    auto initialize_population = [&population, &dis, &gen]() {
        for (auto& individual : population) {
            for (auto& value : individual) {
                value = dis(gen);
            }
        }
    };

    auto evaluate_population = [&fitness_values, &sphere_fitness](const std::vector<std::vector<double>>& population) {
        for (size_t i = 0; i < population.size(); ++i) {
            fitness_values[i] = sphere_fitness(population[i]);
        }
    };

    auto find_best = [&best_solution, &fitness_values, &population](const std::vector<double>& current_best, double current_fitness) {
        for (size_t i = 0; i < population.size(); ++i) {
            double current_fitness = fitness_values[i];
            if (current_fitness < best_fitness) {
                best_fitness = current_fitness;
                best_solution = population[i];
            }
        }
    };

    initialize_population();
    evaluate_population();
    find_best(best_position, fitness_values[0]);

    for (int iter = 0; iter < max_iter; ++iter) {
        // Update population positions and velocities...
        // This part should be implemented with the logic for position and velocity updates.
        // ...

        evaluate_population();
        find_best(best_position, best_fitness);
    }
}

int main() {
    std::vector<double> best_position(2);
    hho(best_position, 2, 20, 100);
    std::cout << "Best position: [" << best_position[0] << ", " << best_position[1] << "]" << std::endl;
    return 0;
}