遺傳演算法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:15:08 瀏覽：86

best把槍密碼多少發布：2025-05-15 20:13:42 瀏覽：547

android安裝程序發布：2025-05-15 20:13:20 瀏覽：558

c語言跳出死循環發布：2025-05-15 20:06:04 瀏覽：823

a19處理器相當於安卓哪個水平發布：2025-05-15 20:05:29 瀏覽：638

榮耀9i安卓強行關機按哪個鍵發布：2025-05-15 20:00:32 瀏覽：750

密碼鎖寫什麼最好發布：2025-05-15 19:05:31 瀏覽：782

5的源碼是發布：2025-05-15 19:04:07 瀏覽：719

c語言創建的源文件發布：2025-05-15 18:54:08 瀏覽：611

3個數字密碼鎖有多少種發布：2025-05-15 18:49:48 瀏覽：684

遺傳演算法c語言

與遺傳演算法c語言相關的資訊