c++代码 遗传算法 包含轮盘赌

admin1

1. #include <iostream>
2. #include <vector>
3. #include <random>
4. #include <cmath>
6. // 适应度函数（示例）
7. double fitness(int value) {
8.     return std::abs(value - 50); // 假设我们想要接近值50
9. }
11. // 轮盘赌选择
12. int rouletteWheelSelection(const std::vector<double>& probabilities) {
13.     std::random_device rd;
14.     std::mt19937 gen(rd());
15.     std::uniform_real_distribution<> dis(0.0, probabilities.back());
16.     double sum = std::accumulate(probabilities.begin(), probabilities.end(), 0.0);
17.     double randomValue = dis(gen);
18.     double cumulative = 0.0;
20.     for (size_t i = 0; i < probabilities.size(); ++i) {
21.         cumulative += probabilities[i] / sum;
22.         if (randomValue < cumulative)
23.             return i;
24.     }
26.     return probabilities.size() - 1; // 如果随机值大于所有概率之和，返回最后一个索引
27. }
29. int main() {
30.     // 参数设置
31.     const int populationSize = 100;
32.     const int generations = 200;
33.     const double mutationRate = 0.01;
35.     // 初始化种群
36.     std::vector<int> population(populationSize);
37.     for (int& individual : population) {
38.         individual = std::rand() % 100; // 初始化为0到99之间的随机数
39.     }
41.     // 主循环：遗传算法
42.     for (int generation = 0; generation < generations; ++generation) {
43.         std::vector<double> fitnessValues(populationSize);
44.         std::vector<double> accumulatedFitness(populationSize);
46.         // 计算适应度和累积适应度
47.         for (size_t i = 0; i < population.size(); ++i) {
48.             fitnessValues[i] = fitness(population[i]);
49.             accumulatedFitness[i] = accumulatedFitness[i - 1] + fitnessValues[i];
50.         }
51.         accumulatedFitness[populationSize - 1] = accumulatedFitness[populationSize - 2] + fitnessValues[populationSize - 1];
53.         // 选择、交叉和变异操作
54.         std::vector<int> newPopulation(populationSize);
55.         for (size_t i = 0; i < population.size(); ++i) {
56.             // 轮盘赌选择
57.             int parent1 = rouletteWheelSelection(accumulatedFitness);
58.             int parent2 = rouletteWheelSelection(accumulatedFitness);
60.             // 交叉（这里使用简单的一点交叉）
61.             int crossoverPoint = std::rand() % 100; // 随机选择交叉点
62.             newPopulation[i] = (parent1 * (100 - crossoverPoint) + parent2 * crossoverPoint) / 100;
64.             // 变异
65.             if (std::rand() < mutationRate * RAND_MAX) {
66.                 newPopulation[i] = std::rand() % 100; // 变异为新随机数
67.             }
68.         }
70.         // 更新种群
71.         population = newPopulation;
73.         // 输出当前代的最优解
74.         double bestFitness = *std::min_element(population.begin(), population.end(), [](int a, int b) { return fitness(a) > fitness(b); });
75.         std::cout << "Generation " << generation << ": Best Fitness = " << bestFitness << std::endl;
76.     }
78.     return 0;
79. }

复制代码

admin

遗传算法是一种搜索启发式算法，灵感来源于自然选择和遗传学原理，常用于优化和搜索问题。下面是一个简化的遗传算法示例，使用轮盘赌选择（roulette wheel selection）来进行个体的选择，以解决一个简单的最大化问题。我们将尝试最大化一个由二进制编码表示的目标函数。

1. ```cpp
2. #include <iostream>
3. #include <vector>
4. #include <cstdlib>
5. #include <ctime>
6. #include <algorithm>
7. #include <numeric>
9. // 个体类
10. class Individual {
11. public:
12.     std::vector<int> genes; // 基因，即二进制编码
13.     double fitness; // 适应度
15.     Individual(int geneLength) : genes(geneLength), fitness(0.0) {
16.         // 初始化基因
17.         for (int& g : genes) {
18.             g = rand() % 2;
19.         }
20.     }
22.     void calculateFitness() {
23.         // 假设目标函数是要最大化二进制编码表示的十进制数
24.         fitness = std::accumulate(genes.begin(), genes.end(), 0.0,
25.                                   [](double total, int bit) { return total * 2 + bit; });
26.     }
27. };
29. // 轮盘赌选择
30. Individual rouletteWheelSelection(const std::vector<Individual>& population) {
31.     double totalFitness = std::accumulate(population.begin(), population.end(), 0.0,
32.                                           [](double total, const Individual& ind) { return total + ind.fitness; });
34.     double pick = static_cast<double>(rand()) / RAND_MAX * totalFitness;
35.     double current = 0.0;
37.     for (const auto& individual : population) {
38.         current += individual.fitness;
39.         if (current > pick) {
40.             return individual;
41.         }
42.     }
44.     // 默认返回最后一个个体
45.     return population.back();
46. }
48. // 遗传算法主循环
49. void geneticAlgorithm(int populationSize, int geneLength, int generations) {
50.     srand(static_cast<unsigned int>(time(nullptr)));
52.     std::vector<Individual> population(populationSize);
53.     for (auto& individual : population) {
54.         individual.genes.resize(geneLength);
55.     }
57.     for (int generation = 0; generation < generations; ++generation) {
58.         for (auto& individual : population) {
59.             individual.calculateFitness();
60.         }
62.         // 打印当前最优个体的适应度
63.         std::sort(population.begin(), population.end(),
64.                   [](const Individual& a, const Individual& b) { return a.fitness > b.fitness; });
65.         std::cout << "Generation " << generation << ": Best Fitness = " << population.front().fitness << std::endl;
67.         std::vector<Individual> newPopulation;
68.         while (newPopulation.size() < populationSize) {
69.             Individual parent1 = rouletteWheelSelection(population);
70.             Individual parent2 = rouletteWheelSelection(population);
71.             // 进行交叉和变异，生成新个体
72.             Individual child = parent1; // 假设无交叉，直接复制父代
73.             // 变异操作
74.             for (int i = 0; i < geneLength; ++i) {
75.                 if (static_cast<double>(rand()) / RAND_MAX < 0.05) { // 变异概率5%
76.                     child.genes[i] = 1 - child.genes[i];
77.                 }
78.             }
79.             newPopulation.push_back(child);
80.         }
81.         population = newPopulation;
82.     }
83. }
85. int main() {
86.     geneticAlgorithm(100, 10, 100); // 100个个体，每个个体10个基因，运行100代
87.     return 0;
88. }
89. ```

复制代码

在上述代码中，我们定义了一个`Individual`类来表示个体，它包含了一组基因（`genes`）和一个适应度值（`fitness`）。遗传算法的主要循环包括计算适应度、轮盘赌选择、交叉和变异等步骤。这里为了简化，我们省略了交叉操作，只进行了变异。轮盘赌选择是基于个体适应度的大小来进行选择，适应度越高的个体被选中的概率越大。

请注意，遗传算法的效果很大程度上取决于问题的特性、种群大小、基因长度、交叉和变异策略等参数的设置。在实际应用中，可能需要对这些参数进行调整以获得最佳效果。