遗传算法c语言

发布时间: 2022-05-18 20:46:07

⑴ c语言实现*/遗传算法改进BP神经网络原理和算法实现怎么弄

遗传算法有相当大的引用。遗传算法在游戏中应用的现状在遗传编码时, 一般将瓦片的坐标作为基因进行实数编码, 染色体的第一个基因为起点坐标, 最后一个基因为终点坐标, 中间的基因为路径经过的每一个瓦片的坐标。在生成染色体时, 由起点出发, 随机选择当前结点的邻居节点中的可通过节点, 将其坐标加入染色体, 依此循环, 直到找到目标点为止, 生成了一条染色体。重复上述操作, 直到达到指定的种群规模。遗传算法的优点：1、遗传算法是以决策变量的编码作为运算对象，可以直接对集合、序列、矩阵、树、图等结构对象进行操作。这样的方式一方面有助于模拟生物的基因、染色体和遗传进化的过程，方便遗传操作算子的运用。另一方面也使得遗传算法具有广泛的应用领域，如函数优化、生产调度、自动控制、图像处理、机器学习、数据挖掘等领域。2、遗传算法直接以目标函数值作为搜索信息。它仅仅使用适应度函数值来度量个体的优良程度，不涉及目标函数值求导求微分的过程。因为在现实中很多目标函数是很难求导的，甚至是不存在导数的，所以这一点也使得遗传算法显示出高度的优越性。3、遗传算法具有群体搜索的特性。它的搜索过程是从一个具有多个个体的初始群体P(0)开始的，一方面可以有效地避免搜索一些不必搜索的点。另一方面由于传统的单点搜索方法在对多峰分布的搜索空间进行搜索时很容易陷入局部某个单峰的极值点，而遗传算法的群体搜索特性却可以避免这样的问题，因而可以体现出遗传算法的并行化和较好的全局搜索性。4、遗传算法基于概率规则，而不是确定性规则。这使得搜索更为灵活，参数对其搜索效果的影响也尽可能的小。5、遗传算法具有可扩展性，易于与其他技术混合使用。以上几点便是遗传算法作为优化算法所具备的优点。遗传算法的缺点：遗传算法在进行编码时容易出现不规范不准确的问题。

⑵ 求遗传算法（GA）C语言代码

.----来个例子，大家好理解..--
基于遗传算法的人工生命模拟
#include<stdio.h>
#include<stdlib.h>
#include<graphics.h>
#include<math.h>
#include<time.h>
#include<string.h>
#include "graph.c"
/* 宏定义 */
#define TL1 20 /* 植物性食物限制时间 */
#define TL2 5 /* 动物性食物限制时间 */
#define NEWFOODS 3 /* 植物性食物每代生成数目 */
#define MUTATION 0.05 /* 变异概率 */
#define G_LENGTH 32 /* 个体染色体长度 */
#define MAX_POP 100 /* 个体总数的最大值 */
#define MAX_FOOD 100 /* 食物总数的最大值 */
#define MAX_WX 60 /* 虚拟环境的长度最大值 */
#define MAX_WY 32 /* 虚拟环境的宽度最大值 */
#define SX1 330 /* 虚拟环境图左上角点x坐标 */
#define SY1 40 /* 虚拟环境图左上角点y坐标 */
#define GX 360 /* 个体数进化图形窗口的左上角点X坐标 */
#define GY 257 /* 个体数进化图形窗口的左上角点Y坐标 */
#define GXR 250 /* 个体数进化图形窗口的长度 */
#define GYR 100 /* 个体数进化图形窗口的宽度 */
#define GSTEP 2 /* 个体数进化图形窗口的X方向步长 */
#define R_LIFE 0.05 /* 初期产生生物数的环境比率 */
#define R_FOOD 0.02 /* 初期产生食物数的环境比率 */
#define SL_MIN 10 /* 个体寿命最小值 */
/* 全局变量 */
unsigned char gene[MAX_POP][G_LENGTH]; /* 遗传基因 */
unsigned char iflg[MAX_POP]; /* 个体死活状态标志变量 */

⑶ 如图，如何用这个PSO算法或遗传算法来求函数极值,用C语言编写代码

需要很多的子函数 %子程序：新物种交叉操作，函数名称存储为crossover.m function scro=crossover(population,seln,pc); BitLength=size(population,2); pcc=IfCroIfMut(pc);%根据交叉概率决定是否进行交叉操作，1则是，0则否 if pcc==1 chb=round(rand*(BitLength-2))+1;%在[1，BitLength-1]范围内随机产生一个交叉位 scro(1,:)=[population(seln(1),1:chb) population(seln(2),chb+1:BitLength)] scro(2,:)=[population(seln(2),1:chb) population(seln(1),chb+1:BitLength)] else scro(1,:)=population(seln(1),:); scro(2,:)=population(seln(2),:); end %子程序：计算适应度函数，函数名称存储为fitnessfun.m function [Fitvalue,cumsump]=fitnessfun(population); global BitLength global boundsbegin global boundsend popsize=size(population,1);%有popsize个个体 for i=1:popsize x=transform2to10(population(i,:));%将二进制转换为十进制 %转化为[-2，2]区间的实数 xx=boundsbegin+x*(boundsend-boundsbegin)/(power(2,BitLength)-1); Fitvalue(i)=targetfun(xx);%计算函数值，即适应度 end %给适...
望采纳！

⑷ C语言遗传算法在求解TSP问题毕业论文+源代码

目
录
摘要
I
Abstract
II
引
言
1
第一章
基本遗传算法
2
1.1
遗传算法的产生及发展
3
1.2
基本原理
3
1.3
遗传算法的特点
3
1.4
基本遗传算法描述
5
1.5
遗传算法构造流程
6
第二章
遗传算法的实现技术
6
2.1
编码方法
7
2.1.1
二进制编码
7
2.1.2
格雷码编码
7
2.1.3
符点数编码
8
2.1.4
参数编码
8
2.2
适应度函数
10
2.3
选择算子
10
2.4
交叉算子
10
2.4.1
单点交叉算子
10
2.4.2
双点交叉算子
11
2.4.3
均匀交叉算子
11
2.4.4
部分映射交叉
11
2.4.5
顺序交叉
12
2.5
变异算子
12
2.6
运行参数
12
2.7
约束条件的处理方法
13
2.8
遗传算法流程图
14
第三章
遗传算法在TSP上的应用
15
3.1
TSP问题的建模与描述
15
3.2
对TSP的遗传基因编码方法
16
3.3
针对TSP的遗传操作算子
17
3.3.1
选择算子
17
3.3.1.1
轮盘赌选择
17
3.3.1.2
最优保存策略选择
17
3.3.2
交叉算子
20
3.3.2.1
单点交叉
20
3.3.2.2
部分映射交叉
21
3.3.3
变异算子
23
3.4
TSP的混和遗传算法
26
第四章
实例分析
27
4.1
测试数据
27
4.2
测试结果
27
4.3
结果分析
27
摘
要
TSP
(Traveling
Salesman
Problem)旅行商问题是一类典型的NP完全问题，遗传算法是解决NP问题的一种较理想的方法。文章首先介绍了基本遗传算法的基本原理、特点及其基本实现技术；接着针对TSP
问题，论述了遗传算法在编码表示和遗传算子（包括选择算子、交叉算子变异算子这三种算子）等方面的应用情况，分别指出几种常用的编码方法的优点和缺点，并且结合TSP的运行实例详细分析了基本遗传算法的4个运行参数群体大小、遗传算法的终止进化代数、交叉概率、变异概率，对遗传算法的求解结果和求解效率的影响，经过多次的测试设定出了它们一组比较合理的取值。最后，简单说明了混合遗传算法在求解TSP问题中的应用并对遗传算法解决TSP问题的前景提出了展望。
关键词：TSP
遗传算法
遗传算子
编码
@@@需要的话按我的名字找我吧

⑸ C语言遗传算法求f(x,y)=(1-x)^2+100(y-x^2)^2 的最小值 x,y都属于【0，2】

#include"stdio.h"
#include"math.h"

#defineNUM(64)
#defineBITS(20)
typedefunsignedintuint;
typedefstruct{
uintd;
doublev;
doublex;
doubley;
}One;

typedefstruct{
Onepop[NUM];
}Gen;

Gengroup;

#defineRand_pop()(rand()&((1<<BITS)-1))

doublerange[2][2]={{0.0,2.0},{0.0,2.0}};

//minasbest
doubleget_value(doublex,doubley){
returnpow(1.0-x,2)+100.0*pow(y-x*x,2);
}

voidget_xy(uintv,double*xx,double*yy){
uintmx=(1<<(BITS/2));
uintx=v&(mx-1);
uinty=v>>(BITS/2);
*xx=range[0][0]+x*range[0][1]/mx;
*yy=range[1][0]+y*range[1][1]/mx;
}

voidset_one(One*one,uintd)
{
one->d=d;
get_xy(d,&one->x,&one->y);
one->v=get_value(one->x,one->y);
}
voidhalf_range(double*range,doublex){
doublehf=range[1]*0.3;
if(x-hf>range[0]){
range[0]=x-hf;
}
range[1]=hf*2;
}

voidscale_range()
{
One*one=&group.pop[0];
inti;
uinthf=BITS/2;
uintmx=(1<<hf);
half_range(range[0],one->x);
half_range(range[1],one->y);

for(i=0;i<NUM;i++){
if(one[i].x>range[0][0]&&
one[i].x<range[0][0]+range[0][1]&&
one[i].y>range[1][0]&&
one[i].y<range[1][0]+range[1][1]){
one[i].d=(uint)((one[i].x-range[0][0])/range[0][1]*mx)+
((uint)((one[i].y-range[1][0])/range[1][1]*mx)<<hf);
}
else{
set_one(&one[i],one[i].d);
}
}
printf("
");
}


intinit_pop(){
inti;
One*one=&group.pop[0];
for(i=0;i<NUM;i++){
uintd=Rand_pop();
set_one(one,d);
one++;
}
return0;
}

intsort_pop()
{
inti,j;
One*one=&group.pop[0];
for(i=0;i<NUM-1;i++){
for(j=i+1;j<NUM;j++){
if(one[i].v>one[j].v){
Onetmp;
tmp=one[i];
one[i]=one[j];
one[j]=tmp;
}
}
}
}
voidbest_pop(intloop)
{
One*one=&group.pop[0];
printf("loop%d:x[%lf%lf]y[%lf%lf]
",loop,range[0][0],range[0][1],range[1][0],range[1][1]);
printf("x:%lfy:%lfvalue:%lf

",one->x,one->y,one->v);
}

uintRand_bits(uint*pos){
uintl,p;
uintr=rand();
p=r%BITS;
l=(r>>5)%3;
if(l+p>=BITS)l=1;
if(pos)*pos=p;
return((1<<l)-1)<<p;
}
uintRand_sel(){
uintr=rand();
uintc=r%100;
uintl=NUM/4;
uintv=(r>>7)%l;
if(c>65){
returnv;
}
if(c>35){
returnl+v;
}
if(c>10){
return(l*2)+v;
}
returnl*3+v;
}
#defineSWAP(m,n,type){type_tmp;_tmp=m;m=n;n=_tmp;}
voidsel_pop2(One*a,One*b,One*ga,One*gb)
{
if(a->v>b->v)SWAP(a,b,One*);
if(ga->v>gb->v)SWAP(ga,gb,One*);
if(ga->v<a->v)*a=*ga;
if(gb->v<b->v)*b=*gb;
}

voidcross_pop(One*a,One*b){
uintbit;
Onega,gb,*g1=&ga,*g2=&gb;
bit=Rand_bits(NULL);
set_one(&ga,(a->d&bit)|(b->d&~bit));
set_one(&gb,(b->d&bit)|(a->d&~bit));
sel_pop2(a,b,&ga,&gb);
}

voidchg_pop(){
uintbit,d,pos;
One*one,ga;
uints=Rand_sel();
uintraw;
one=&group.pop[s];
bit=Rand_bits(&pos);
raw=(~one->d)&bit;
d=raw|((~bit)&one->d);
set_one(&ga,d);
if(ga.v<one->v){
*one=ga;
}
}

voiditer_pop()
{
inti;
One*one=&group.pop[0];
sort_pop();
for(i=0;i<NUM;i++){
uinta,b;
chg_pop();
a=Rand_sel();
do{
b=Rand_sel();
}while(a==b);
cross_pop(&one[a],&one[b]);
}
}

#defineMAX_LOOP(100)
intmain(){
inti;
srand(time(NULL));
init_pop();
for(i=0;i<MAX_LOOP;i++){
iter_pop();
best_pop(i);
if(i&&i%5==0)scale_range();
}
return0;
}

⑹ c语言中遗传算法的种群的适应度是什么

种群适应度就是演化的目标啊，比如说01背包问题，一个背包中所放物品的价值就是适应度，通过不断的变异交叉，适应度会发生改变，每次只选出适应度更高的个体就好了

⑺ 遗传算法的C语言实现

一个非常简单的遗传算法源代码，是由Denis Cormier (North Carolina State University)开发的，Sita S.Raghavan (University of North Carolina at Charlotte)修正。代码保证尽可能少，实际上也不必查错。对一特定的应用修正此代码，用户只需改变常数的定义并且定义“评价函数”即可。注意代码的设计是求最大值，其中的目标函数只能取正值；且函数值和个体的适应值之间没有区别。该系统使用比率选择、精华模型、单点杂交和均匀变异。如果用Gaussian变异替换均匀变异，可能得到更好的效果。代码没有任何图形，甚至也没有屏幕输出，主要是保证在平台之间的高可移植性。读者可以从ftp.uncc.e,目录 coe/evol中的文件prog.c中获得。要求输入的文件应该命名为‘gadata.txt’；系统产生的输出文件为‘galog.txt’。输入的文件由几行组成：数目对应于变量数。且每一行提供次序——对应于变量的上下界。如第一行为第一个变量提供上下界，第二行为第二个变量提供上下界，等等。

/**************************************************************************/
/* This is a simple genetic algorithm implementation where the */
/* evaluation function takes positive values only and the */
/* fitness of an indivial is the same as the value of the */
/* objective function */
/**************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

/* Change any of these parameters to match your needs */

#define POPSIZE 50 /* population size */
#define MAXGENS 1000 /* max. number of generations */
#define NVARS 3 /* no. of problem variables */
#define PXOVER 0.8 /* probability of crossover */
#define PMUTATION 0.15 /* probability of mutation */
#define TRUE 1
#define FALSE 0

int generation; /* current generation no. */
int cur_best; /* best indivial */
FILE *galog; /* an output file */

struct genotype /* genotype (GT), a member of the population */
{
double gene[NVARS]; /* a string of variables */
double fitness; /* GT's fitness */
double upper[NVARS]; /* GT's variables upper bound */
double lower[NVARS]; /* GT's variables lower bound */
double rfitness; /* relative fitness */
double cfitness; /* cumulative fitness */
};

struct genotype population[POPSIZE+1]; /* population */
struct genotype newpopulation[POPSIZE+1]; /* new population; */
/* replaces the */
/* old generation */

/* Declaration of proceres used by this genetic algorithm */

void initialize(void);
double randval(double, double);
void evaluate(void);
void keep_the_best(void);
void elitist(void);
void select(void);
void crossover(void);
void Xover(int,int);
void swap(double *, double *);
void mutate(void);
void report(void);

/***************************************************************/
/* Initialization function: Initializes the values of genes */
/* within the variables bounds. It also initializes (to zero) */
/* all fitness values for each member of the population. It */
/* reads upper and lower bounds of each variable from the */
/* input file `gadata.txt'. It randomly generates values */
/* between these bounds for each gene of each genotype in the */
/* population. The format of the input file `gadata.txt' is */
/* var1_lower_bound var1_upper bound */
/* var2_lower_bound var2_upper bound ... */
/***************************************************************/

void initialize(void)
{
FILE *infile;
int i, j;
double lbound, ubound;

if ((infile = fopen("gadata.txt","r"))==NULL)
{
fprintf(galog,"\nCannot open input file!\n");
exit(1);
}

/* initialize variables within the bounds */

for (i = 0; i < NVARS; i++)
{
fscanf(infile, "%lf",&lbound);
fscanf(infile, "%lf",&ubound);

for (j = 0; j < POPSIZE; j++)
{
population[j].fitness = 0;
population[j].rfitness = 0;
population[j].cfitness = 0;
population[j].lower[i] = lbound;
population[j].upper[i]= ubound;
population[j].gene[i] = randval(population[j].lower[i],
population[j].upper[i]);
}
}

fclose(infile);
}

/***********************************************************/
/* Random value generator: Generates a value within bounds */
/***********************************************************/

double randval(double low, double high)
{
double val;
val = ((double)(rand()%1000)/1000.0)*(high - low) + low;
return(val);
}

/*************************************************************/
/* Evaluation function: This takes a user defined function. */
/* Each time this is changed, the code has to be recompiled. */
/* The current function is: x[1]^2-x[1]*x[2]+x[3] */
/*************************************************************/

void evaluate(void)
{
int mem;
int i;
double x[NVARS+1];

for (mem = 0; mem < POPSIZE; mem++)
{
for (i = 0; i < NVARS; i++)
x[i+1] = population[mem].gene[i];

population[mem].fitness = (x[1]*x[1]) - (x[1]*x[2]) + x[3];
}
}

/***************************************************************/
/* Keep_the_best function: This function keeps track of the */
/* best member of the population. Note that the last entry in */
/* the array Population holds a of the best indivial */
/***************************************************************/

void keep_the_best()
{
int mem;
int i;
cur_best = 0; /* stores the index of the best indivial */

for (mem = 0; mem < POPSIZE; mem++)
{
if (population[mem].fitness > population[POPSIZE].fitness)
{
cur_best = mem;
population[POPSIZE].fitness = population[mem].fitness;
}
}
/* once the best member in the population is found, the genes */
for (i = 0; i < NVARS; i++)
population[POPSIZE].gene[i] = population[cur_best].gene[i];
}

/****************************************************************/
/* Elitist function: The best member of the previous generation */
/* is stored as the last in the array. If the best member of */
/* the current generation is worse then the best member of the */
/* previous generation, the latter one would replace the worst */
/* member of the current population */
/****************************************************************/

void elitist()
{
int i;
double best, worst; /* best and worst fitness values */
int best_mem, worst_mem; /* indexes of the best and worst member */

best = population[0].fitness;
worst = population[0].fitness;
for (i = 0; i < POPSIZE - 1; ++i)
{
if(population[i].fitness > population[i+1].fitness)
{
if (population[i].fitness >= best)
{
best = population[i].fitness;
best_mem = i;
}
if (population[i+1].fitness <= worst)
{
worst = population[i+1].fitness;
worst_mem = i + 1;
}
}
else
{
if (population[i].fitness <= worst)
{
worst = population[i].fitness;
worst_mem = i;
}
if (population[i+1].fitness >= best)
{
best = population[i+1].fitness;
best_mem = i + 1;
}
}
}
/* if best indivial from the new population is better than */
/* the best indivial from the previous population, then */
/* the best from the new population; else replace the */
/* worst indivial from the current population with the */
/* best one from the previous generation */

if (best >= population[POPSIZE].fitness)
{
for (i = 0; i < NVARS; i++)
population[POPSIZE].gene[i] = population[best_mem].gene[i];
population[POPSIZE].fitness = population[best_mem].fitness;
}
else
{
for (i = 0; i < NVARS; i++)
population[worst_mem].gene[i] = population[POPSIZE].gene[i];
population[worst_mem].fitness = population[POPSIZE].fitness;
}
}
/**************************************************************/
/* Selection function: Standard proportional selection for */
/* maximization problems incorporating elitist model - makes */
/* sure that the best member survives */
/**************************************************************/

void select(void)
{
int mem, i, j, k;
double sum = 0;
double p;

/* find total fitness of the population */
for (mem = 0; mem < POPSIZE; mem++)
{
sum += population[mem].fitness;
}

/* calculate relative fitness */
for (mem = 0; mem < POPSIZE; mem++)
{
population[mem].rfitness = population[mem].fitness/sum;
}
population[0].cfitness = population[0].rfitness;

/* calculate cumulative fitness */
for (mem = 1; mem < POPSIZE; mem++)
{
population[mem].cfitness = population[mem-1].cfitness +
population[mem].rfitness;
}

/* finally select survivors using cumulative fitness. */

for (i = 0; i < POPSIZE; i++)
{
p = rand()%1000/1000.0;
if (p < population[0].cfitness)
newpopulation[i] = population[0];
else
{
for (j = 0; j < POPSIZE;j++)
if (p >= population[j].cfitness &&
p<population[j+1].cfitness)
newpopulation[i] = population[j+1];
}
}
/* once a new population is created, it back */

for (i = 0; i < POPSIZE; i++)
population[i] = newpopulation[i];
}

/***************************************************************/
/* Crossover selection: selects two parents that take part in */
/* the crossover. Implements a single point crossover */
/***************************************************************/

void crossover(void)
{
int i, mem, one;
int first = 0; /* count of the number of members chosen */
double x;

for (mem = 0; mem < POPSIZE; ++mem)
{
x = rand()%1000/1000.0;
if (x < PXOVER)
{
++first;
if (first % 2 == 0)
Xover(one, mem);
else
one = mem;
}
}
}
/**************************************************************/
/* Crossover: performs crossover of the two selected parents. */
/**************************************************************/

void Xover(int one, int two)
{
int i;
int point; /* crossover point */

/* select crossover point */
if(NVARS > 1)
{
if(NVARS == 2)
point = 1;
else
point = (rand() % (NVARS - 1)) + 1;

for (i = 0; i < point; i++)
swap(&population[one].gene[i], &population[two].gene[i]);

}
}

/*************************************************************/
/* Swap: A swap procere that helps in swapping 2 variables */
/*************************************************************/

void swap(double *x, double *y)
{
double temp;

temp = *x;
*x = *y;
*y = temp;

}

/**************************************************************/
/* Mutation: Random uniform mutation. A variable selected for */
/* mutation is replaced by a random value between lower and */
/* upper bounds of this variable */
/**************************************************************/

void mutate(void)
{
int i, j;
double lbound, hbound;
double x;

for (i = 0; i < POPSIZE; i++)
for (j = 0; j < NVARS; j++)
{
x = rand()%1000/1000.0;
if (x < PMUTATION)
{
/* find the bounds on the variable to be mutated */
lbound = population[i].lower[j];
hbound = population[i].upper[j];
population[i].gene[j] = randval(lbound, hbound);
}
}
}

/***************************************************************/
/* Report function: Reports progress of the simulation. Data */
/* mped into the output file are separated by commas */
/***************************************************************/
。。。。。
代码太多你到下面呢个网站看看吧

void main(void)
{
int i;

if ((galog = fopen("galog.txt","w"))==NULL)
{
exit(1);
}
generation = 0;

fprintf(galog, "\n generation best average standard \n");
fprintf(galog, " number value fitness deviation \n");

initialize();
evaluate();
keep_the_best();
while(generation<MAXGENS)
{
generation++;
select();
crossover();
mutate();
report();
evaluate();
elitist();
}
fprintf(galog,"\n\n Simulation completed\n");
fprintf(galog,"\n Best member: \n");

for (i = 0; i < NVARS; i++)
{
fprintf (galog,"\n var(%d) = %3.3f",i,population[POPSIZE].gene[i]);
}
fprintf(galog,"\n\n Best fitness = %3.3f",population[POPSIZE].fitness);
fclose(galog);
printf("Success\n");
}

⑻ c语言遗传算法解码问题

intDecode(chars[],intD[]){
	inti,j,k,list[8]={150,200,250,300,350,500,400,450};
	if(strlen(s)!=51)return0;
	for(i=0;i<51;i+=3){
		k=0;
		for(j=i;j<i+3;++j)
			k=2*k+s[j]-'0';
		D[i/3]=list[k];
	}
	return1;
}

⑼ 用C语言编遗传算法调试结果这个样子是怎么回事啊

估计是代码格式不合法，检查是否有{}不配对，丢失行尾';'，或中文全角标点的情况吧。

⑽ 帮帮忙，用c语言写一个遗传算法程序解决y=x*x的最大值问题，x取0--31

阅读全文

热点内容

编程找点发布：2025-05-15 20:43:10 浏览：587

php上传临时文件夹发布：2025-05-15 20:43:00 浏览：657

impala数据库发布：2025-05-15 20:42:12 浏览：649

android安装插件发布：2025-05-15 20:41:31 浏览：241

神秘顾客访问发布：2025-05-15 20:33:39 浏览：298

安卓市场手机版从哪里下载发布：2025-05-15 20:17:28 浏览：815

幼儿速算法发布：2025-05-15 20:15:08 浏览：87

best把枪密码多少发布：2025-05-15 20:13:42 浏览：549

android安装程序发布：2025-05-15 20:13:20 浏览：560

c语言跳出死循环发布：2025-05-15 20:06:04 浏览：825

遗传算法c语言

与遗传算法c语言相关的资讯