遗传算法求最大值 人工智能 c++

以下是一个使用C++实现的简单遗传算法求解函数最大值的示例代码：

#include <iostream>
#include <cmath>
#include <vector>
#include <cstdlib>
#include <ctime>

using namespace std;

// 定义适应度函数f(x)为x*sin(10*pi*x)+2.0
double fitness(double x) {
    return x*sin(10.0*M_PI*x) + 2.0;
}

// 定义个体结构体，包括个体基因和适应度
struct Individual {
    vector<double> genes;
    double fitness;
};

// 定义遗传算法参数
const int POPULATION_SIZE = 100; // 种群大小
const int NUM_GENES = 10; // 基因数
const double CROSSOVER_RATE = 0.8; // 交叉概率
const double MUTATION_RATE = 0.1; // 变异概率
const int MAX_GENERATIONS = 1000; // 最大迭代次数

// 初始化种群
void initializePopulation(vector<Individual>& population) {
    for (int i = 0; i < POPULATION_SIZE; i++) {
        Individual individual;
        for (int j = 0; j < NUM_GENES; j++) {
            individual.genes.push_back((double)rand() / RAND_MAX);
        }
        individual.fitness = fitness(individual.genes[0]);
        population.push_back(individual);
    }
}

// 选择操作，采用轮盘赌选择方法
Individual select(vector<Individual>& population) {
    double sumFitness = 0.0;
    for (int i = 0; i < POPULATION_SIZE; i++) {
        sumFitness += population[i].fitness;
    }
    double randFitness = (double)rand() / RAND_MAX * sumFitness;
    double curFitness = 0.0;
    for (int i = 0; i < POPULATION_SIZE; i++) {
        curFitness += population[i].fitness;
        if (curFitness >= randFitness) {
            return population[i];
        }
    }
}

// 交叉操作，采用单点交叉方法
Individual crossover(Individual parent1, Individual parent2) {
    Individual child;
    int crossoverPoint = rand() % NUM_GENES;
    for (int i = 0; i < crossoverPoint; i++) {
        child.genes.push_back(parent1.genes[i]);
    }
    for (int i = crossoverPoint; i < NUM_GENES; i++) {
        child.genes.push_back(parent2.genes[i]);
    }
    child.fitness = fitness(child.genes[0]);
    return child;
}

// 变异操作，采用高斯变异方法
Individual mutate(Individual individual) {
    for (int i = 0; i < NUM_GENES; i++) {
        if ((double)rand() / RAND_MAX < MUTATION_RATE) {
            double delta = (double)rand() / RAND_MAX - 0.5;
            individual.genes[i] += delta;
            if (individual.genes[i] < 0.0) {
                individual.genes[i] = 0.0;
            }
            if (individual.genes[i] > 1.0) {
                individual.genes[i] = 1.0;
            }
        }
    }
    individual.fitness = fitness(individual.genes[0]);
    return individual;
}

// 迭代遗传算法
void geneticAlgorithm() {
    vector<Individual> population;
    initializePopulation(population);
    int generation = 0;
    while (generation < MAX_GENERATIONS) {
        vector<Individual> newPopulation;
        for (int i = 0; i < POPULATION_SIZE; i++) {
            // 选择操作
            Individual parent1 = select(population);
            Individual parent2 = select(population);
            // 交叉操作
            if ((double)rand() / RAND_MAX < CROSSOVER_RATE) {
                Individual child = crossover(parent1, parent2);
                // 变异操作
                child = mutate(child);
                newPopulation.push_back(child);
            } else {
                newPopulation.push_back(parent1);
            }
        }
        population = newPopulation;
        generation++;
    }
    // 输出最优解
    double maxFitness = -numeric_limits<double>::max();
    vector<double> maxGenes;
    for (int i = 0; i < POPULATION_SIZE; i++) {
        if (population[i].fitness > maxFitness) {
            maxFitness = population[i].fitness;
            maxGenes = population[i].genes;
        }
    }
    cout << "Max fitness: " << maxFitness << endl;
    cout << "Max genes: ";
    for (int i = 0; i < NUM_GENES; i++) {
        cout << maxGenes[i] << " ";
    }
    cout << endl;
}

int main() {
    srand(time(NULL));
    geneticAlgorithm();
    return 0;
}

在上述代码中，适应度函数f(x)为x*sin(10*pi*x)+2.0，个体采用实数编码，种群大小为100，基因数为10，交叉概率为0.8，变异概率为0.1，最大迭代次数为1000。初始化种群时，采用随机生成的方式，每个基因的值为[0,1]之间的随机数。选择操作采用轮盘赌选择方法，交叉操作采用单点交叉方法，变异操作采用高斯变异方法。在迭代过程中，每次选择两个父代个体进行交叉操作，如果发生交叉，则进行变异操作，生成一个新的子代个体。最终输出种群中适应度最高的个体作为最优解。