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

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`）。遗传算法的主要循环包括计算适应度、轮盘赌选择、交叉和变异等步骤。这里为了简化，我们省略了交叉操作，只进行了变异。轮盘赌选择是基于个体适应度的大小来进行选择，适应度越高的个体被选中的概率越大。

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