粒子群优化算法（C＋＋实现）

粒子群优化算法（Particle Swarm Optimization，PSO）是一种常用的群体智能算法，主要用于求解连续优化问题。它的基本思想是模拟鸟群捕食行为，将每个解看作粒子，通过不断调整粒子的位置和速度来搜索最优解。

以下是一个简单的C++实现粒子群优化算法的代码：

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

using namespace std;

// 目标函数
double func(vector<double> x)
{
    double result = 0.0;
    for (int i=0; i<x.size(); i++)
    {
        result += pow(x[i], 2);
    }
    return result;
}

// 粒子结构体
struct Particle
{
    vector<double> position;    // 当前位置
    vector<double> velocity;    // 当前速度
    vector<double> best_position;   // 个体最佳位置
    double best_score;          // 个体最佳得分
};

// 算法参数
const int MAX_ITERATION = 100;  // 最大迭代次数
const int POPULATION_SIZE = 20; // 粒子数
const double C1 = 2.0;          // 学习因子1
const double C2 = 2.0;          // 学习因子2
const double W = 0.8;           // 惯性因子
const double MIN_POSITION = -5.0;   // 变量最小值
const double MAX_POSITION = 5.0;    // 变量最大值

// 初始化粒子群
void initialize(vector<Particle>& swarm)
{
    random_device rd;
    default_random_engine gen(rd());
    uniform_real_distribution<double> dist(MIN_POSITION, MAX_POSITION);
    for (int i=0; i<POPULATION_SIZE; i++)
    {
        Particle p;
        for (int j=0; j<swarm[0].position.size(); j++)
        {
            p.position.push_back(dist(gen));
            p.velocity.push_back(0.0);
        }
        p.best_position = p.position;
        p.best_score = func(p.position);
        swarm.push_back(p);
    }
}

// 更新粒子速度和位置
void update(vector<Particle>& swarm, vector<double>& global_best_position, double& global_best_score)
{
    for (int i=0; i<POPULATION_SIZE; i++)
    {
        // 更新速度
        for (int j=0; j<swarm[i].velocity.size(); j++)
        {
            double r1 = (double)rand() / RAND_MAX;
            double r2 = (double)rand() / RAND_MAX;
            swarm[i].velocity[j] = W * swarm[i].velocity[j] +
                C1 * r1 * (swarm[i].best_position[j] - swarm[i].position[j]) +
                C2 * r2 * (global_best_position[j] - swarm[i].position[j]);
        }

        // 更新位置
        for (int j=0; j<swarm[i].position.size(); j++)
        {
            swarm[i].position[j] += swarm[i].velocity[j];
            if (swarm[i].position[j] < MIN_POSITION)
            {
                swarm[i].position[j] = MIN_POSITION;
            }
            else if (swarm[i].position[j] > MAX_POSITION)
            {
                swarm[i].position[j] = MAX_POSITION;
            }
        }

        // 更新个体最佳位置
        double score = func(swarm[i].position);
        if (score < swarm[i].best_score)
        {
            swarm[i].best_position = swarm[i].position;
            swarm[i].best_score = score;
        }

        // 更新全局最佳位置
        if (score < global_best_score)
        {
            global_best_position = swarm[i].position;
            global_best_score = score;
        }
    }
}

// 主函数
int main()
{
    vector<Particle> swarm;
    initialize(swarm);

    vector<double> global_best_position = swarm[0].position;
    double global_best_score = swarm[0].best_score;
    for (int i=0; i<MAX_ITERATION; i++)
    {
        update(swarm, global_best_position, global_best_score);
        cout << "Iteration " << i+1 << ": " << global_best_score << endl;
    }

    return 0;
}

在这个实现中，我们定义了一个粒子结构体来存储粒子的位置、速度和最佳位置信息。在初始化函数中，我们使用随机数生成器生成初始位置，并将粒子加入到粒子群中。在更新函数中，我们按照粒子群算法的步骤，首先更新粒子速度，然后根据新速度更新粒子位置，并更新每个粒子的个体最佳位置和全局最佳位置。最后，我们在主函数中执行多次迭代，并输出全局最佳位置和得分。

以上就是一个简单的粒子群优化算法的C++实现。当然，这只是一个基本实现，根据实际应用情况，还可以进一步优化算法参数和实现细节，以获得更好的优化结果。