遗传优化算法 C/C++ 代码怎么写？

ake555

遗传优化算法 C/C++ 代码怎么写？

VIVIANY

遗传优化算法的C/C++代码实现如下：

1. 定义个体结构体

```c++
struct Individual {
    vector<double> genes; // 基因序列
    double fitness; // 适应度值
};
```

2. 初始化种群

```c++
vector<Individual> population; // 种群

// 初始化种群
void initPopulation(int popSize, int geneSize) {
    for (int i = 0; i < popSize; i++) {
        Individual individual;
        for (int j = 0; j < geneSize; j++) {
            individual.genes.push_back(rand() % 100); // 随机生成基因序列
        }
        population.push_back(individual);
    }
}
```

3. 计算适应度值

```c++
// 计算适应度值
double calcFitness(Individual individual) {
    double fitness = 0;
    for (int i = 0; i < individual.genes.size(); i++) {
        fitness += individual.genes;
    }
    return fitness;
}

// 更新种群适应度值
void updateFitness() {
    for (int i = 0; i < population.size(); i++) {
        population.fitness = calcFitness(population);
    }
}
```

4. 选择操作

```c++
// 选择操作
vector<Individual> selection() {
    vector<Individual> parents;
    double totalFitness = 0;
    for (int i = 0; i < population.size(); i++) {
        totalFitness += population.fitness;
    }
    for (int i = 0; i < population.size(); i++) {
        double r = (double)rand() / RAND_MAX * totalFitness;
        double sum = 0;
        for (int j = 0; j < population.size(); j++) {
            sum += population[j].fitness;
            if (sum >= r) {
                parents.push_back(population[j]);
                break;
            }
        }
    }
    return parents;
}
```

5. 交叉操作

```c++
// 交叉操作
vector<Individual> crossover(vector<Individual> parents, double crossoverRate) {
    vector<Individual> offspring;
    for (int i = 0; i < parents.size(); i += 2) {
        if ((double)rand() / RAND_MAX < crossoverRate) {
            int point = rand() % parents.genes.size();
            Individual child1, child2;
            for (int j = 0; j < point; j++) {
                child1.genes.push_back(parents.genes[j]);
                child2.genes.push_back(parents[i + 1].genes[j]);
            }
            for (int j = point; j < parents.genes.size(); j++) {
                child1.genes.push_back(parents[i + 1].genes[j]);
                child2.genes.push_back(parents.genes[j]);
            }
            offspring.push_back(child1);
            offspring.push_back(child2);
        } else {
            offspring.push_back(parents);
            offspring.push_back(parents[i + 1]);
        }
    }
    return offspring;
}
```

6. 变异操作

```c++
// 变异操作
void mutation(vector<Individual>& offspring, double mutationRate) {
    for (int i = 0; i < offspring.size(); i++) {
        for (int j = 0; j < offspring.genes.size(); j++) {
            if ((double)rand() / RAND_MAX < mutationRate) {
                offspring.genes[j] = rand() % 100;
            }
        }
    }
}
```

7. 遗传优化算法主函数

```c++
int main() {
    srand(time(NULL));
    int popSize = 100; // 种群大小
    int geneSize = 10; // 基因序列长度
    double crossoverRate = 0.8; // 交叉概率
    double mutationRate = 0.1; // 变异概率
    int maxGeneration = 100; // 最大迭代次数

    initPopulation(popSize, geneSize);
    updateFitness();

    for (int i = 0; i < maxGeneration; i++) {
        vector<Individual> parents = selection();
        vector<Individual> offspring = crossover(parents, crossoverRate);
        mutation(offspring, mutationRate);
        population = offspring;
        updateFitness();
    }

    // 输出最优

freshfish

遗传优化算法是一种利用自然选择和基因遗传规律进行搜索和优化的算法。下面以二进制遗传算法（Binary Genetic Algorithm，简称BGA）为例，介绍如何用 C/C++ 语言实现遗传优化算法。
BGA 要解决的问题一般都能够通过一个优化函数来描述，如要在一个空间内（N个变量，每个变量有M个取值范围）寻找函数取值最大或最小的点，可以通过寻找优化函数的全局最小值或最大值来完成任务。
以下是 BGA 的 C/C++ 实现过程：
1.首先定义问题的优化函数，并且确定变量的维数、取值范围等问题。
2.然后定义个体（Individual）和种群（Population）的数据结构。每个个体一般包括基因和适应度两个属性，基因是决定个体性状和特征的二进制序列，而适应度则是个体在当前环境下的表现。
3.初始化种群，把每个个体的基因都随机生成。
4.计算每个个体的适应度，并且根据适应度排序。
5.从种群中选择某些个体进行交叉（Crossover）和变异（Mutation）。交叉就是将两个个体的基因进行部分混合并产生新的个体，变异则是随机改变某个个体的某个基因位。
6.重复第4-5步，直到达到结束条件。例如达到固定迭代次数、算法收敛等情况。
7.输出种群中适应度最好的个体的基因序列和对应的适应度值，即为问题的最优解。
参考代码如下所示：

1. ```c++
2. #include <iostream>
3. #include <cstring>
4. #include <cstdlib>
5. #include <ctime>
7. using namespace std;
9. // 问题的维数和每个维度的取值范围
10. const int N = 2;
11. const int L = 0, R = 10;
12. // 种群大小
13. const int POPSIZE = 100;
14. // 迭代次数
15. const int ITERATIONS = 1000;
16. // 交叉概率
17. const double CROSSOVER_PROBABILITY = 0.9;
18. // 变异概率
19. const double MUTATION_PROBABILITY = 0.1;
21. // 个体
22. struct Individual {
23.     int gene[N]; // 基因
24.     double fitness; // 适应度
25. };
27. // 种群
28. struct Population {
29.     Individual individuals[POPSIZE];
30.     double total_fitness; // 种群中所有个体适应度之和
31. };
33. // 优化函数
34. double fitness_function(int x, int y) {
35.     return x * x + y * y;
36. }
38. // 初始化种群
39. void init_population(Population &population) {
40.     for (int i = 0; i < POPSIZE; i++) {
41.         for (int j = 0; j < N; j++) {
42.             population.individuals[i].gene[j] = rand() % (R - L + 1) + L; // 随机生成基因
43.         }
44.         population.individuals[i].fitness = fitness_function(population.individuals[i].gene[0], population.individuals[i].gene[1]); // 计算适应度
45.     }
46.     population.total_fitness = 0;
47.     for (int i = 0; i < POPSIZE; i++) {
48.         population.total_fitness += population.individuals[i].fitness;
49.     }
50. }
52. // 选择
53. Individual select(Population population) {
54.     double fitness_prob[POPSIZE]; // 计算每个个体被选择的概率
55.     double fit_sum = 0;
56.     for (int i = 0; i < POPSIZE; i++) {
57.         fitness_prob[i] = population.individuals[i].fitness / population.total_fitness;
58.         fit_sum += fitness_prob[i];
59.     }
60.     for (int i = 0; i < POPSIZE; i++) {
61.         fitness_prob[i] /= fit_sum; // 归一化
62.     }
63.     // 用轮盘赌算法选择个体
64.     double p = (double) rand() / RAND_MAX; // 随机选择一个概率
65.     int index = 0;
66.     while (p > 0) {
67.         p -= fitness_prob[index];
68.         index++;
69.     }
70.     index--;
71.     return population.individuals[index];
72. }
74. // 交叉
75. void crossover(Individual &a, Individual &b) {
76.     double p = (double) rand() / RAND_MAX; // 随机选择一个概率
77.     if (p > CROSSOVER_PROBABILITY) {
78.         return;
79.     }
80.     int point = rand() % N; // 随机选择一个交叉点
81.     for (int i = point; i < N; i++) { // 交换后半部分
82.         int temp = a.gene[i];
83.         a.gene[i] = b.gene[i];
84.         b.gene[i] = temp;
85.     }
86. }
88. // 变异
89. void mutation(Individual &a) {
90.     double p = (double) rand() / RAND_MAX; // 随机选择一个概率
91.     if (p > MUTATION_PROBABILITY) {
92.         return;
93.     }
94.     int point = rand() % N; // 随机选择一个基因位
95.     a.gene[point] = rand() % (R - L + 1) + L; // 随机改变该位基因的值
96. }
98. // 更新种群
99. void update_population(Population &population) {
100.     Population new_population;
101.     new_population.total_fitness = 0;
102.     // 选择两个个体，进行交叉和变异
103.     for (int i = 0; i < POPSIZE; i++) {
104.         Individual a = select(population);
105.         Individual b = select(population);
106.         crossover(a, b);
107.         mutation(a);
108.         mutation(b);
109.         a.fitness = fitness_function(a.gene[0], a.gene[1]);
110.         b.fitness = fitness_function(b.gene[0], b.gene[1]);
111.         new_population.individuals[i] = a;
112.         new_population.total_fitness += a.fitness;
113.         i++;
114.         if (i >= POPSIZE) {
115.             break;
116.         }
117.         new_population.individuals[i] = b;
118.         new_population.total_fitness += b.fitness;
119.     }
120.     population = new_population;
121. }
123. int main()
124. {
125.     srand(time(NULL)); // 设置随机种子
126.     Population population;
127.     init_population(population);
128.     for (int i = 0; i < ITERATIONS; i++) {
129.         update_population(population);
130.     }
131.     // 输出种群中适应度最好的个体
132.     Individual best = population.individuals[0];
133.     for (int i = 1; i < POPSIZE; i++) {
134.         if (population.individuals[i].fitness > best.fitness) {
135.             best = population.individuals[i];
136.         }
137.     }
138.     cout << "Best individual: ";
139.     for (int i = 0; i < N; i++) {
140.         cout << best.gene[i] << " ";
141.     }
142.     cout << endl << "Fitness value: " << best.fitness << endl;
144.     return 0;
145. }
146. ```

复制代码

上述代码实现了二维优化问题的求解过程，可以根据具体问题和需要进行相应的修改和调整。