遺傳演算法源碼
⑴ 誰有車間作業調度問題遺傳演算法的MATLAB源碼，要完整的程序哦~
function [Zp,Y1p,Y2p,Y3p,Xp,LC1,LC2]=JSPGA(M,N,Pm,T,P)
%--------------------------------------------------------------------------
% JSPGA.m
% 車間作業調度問題遺傳演算法
%--------------------------------------------------------------------------
% 輸入參數列表
% M 遺傳進化迭代次數
% N 種群規模(取偶數)
% Pm 變異概率
% T m×n的矩陣，存儲m個工件n個工序的加工時間
% P 1×n的向量，n個工序中，每一個工序所具有的機床數目
% 輸出參數列表
% Zp 最優的Makespan值
% Y1p 最優方案中，各工件各工序的開始時刻，可根據它繪出甘特圖
% Y2p 最優方案中，各工件各工序的結束時刻，可根據它繪出甘特圖
% Y3p 最優方案中，各工件各工序使用的機器編號
% Xp 最優決策變數的值，決策變數是一個實數編碼的m×n矩陣
% LC1 收斂曲線1，各代最優個體適應值的記錄
% LC2 收斂曲線2，各代群體平均適應值的記錄
% 最後，程序還將繪出三副圖片：兩條收斂曲線圖和甘特圖（各工件的調度時序圖）
%第一步：變數初始化
[m,n]=size(T);%m是總工件數，n是總工序數
Xp=zeros(m,n);%最優決策變數
LC1=zeros(1,M);%收斂曲線1
LC2=zeros(1,N);%收斂曲線2
%第二步：隨機產生初始種群
farm=cell(1,N);%採用細胞結構存儲種群
for k=1:N
X=zeros(m,n);
for j=1:n
for i=1:m
X(i,j)=1+(P(j)-eps)*rand;
end
end
farm{k}=X;
end
counter=0;%設置迭代計數器
while counter
%第三步：交叉
newfarm=cell(1,N);%交叉產生的新種群存在其中
Ser=randperm(N);
for i=1:2:(N-1)
A=farm{Ser(i)};%父代個體
B=farm{Ser(i+1)};
Manner=unidrnd(2);%隨機選擇交叉方式
if Manner==1
cp=unidrnd(m-1);%隨機選擇交叉點
%雙親雙子單點交叉
a=[A(1:cp,:);B((cp+1):m,:)];%子代個體
b=[B(1:cp,:);A((cp+1):m,:)];
else
cp=unidrnd(n-1);%隨機選擇交叉點
a=[A(:,1:cp),B(:,(cp+1):n)];%雙親雙子單點交叉
b=[B(:,1:cp),A(:,(cp+1):n)];
end
newfarm{i}=a;%交叉後的子代存入newfarm
newfarm{i+1}=b;
end
%新舊種群合並
FARM=[farm,newfarm];
%第四步：選擇復制
FITNESS=zeros(1,2*N);
fitness=zeros(1,N);
plotif=0;
for i=1:(2*N)
X=FARM{i};
Z=COST(X,T,P,plotif);%調用計算費用的子函數
FITNESS(i)=Z;
end
%選擇復制採取兩兩隨機配對競爭的方式，具有保留最優個體的能力
Ser=randperm(2*N);
for i=1:N
f1=FITNESS(Ser(2*i-1));
f2=FITNESS(Ser(2*i));
if f1<=f2
farm{i}=FARM{Ser(2*i-1)};
fitness(i)=FITNESS(Ser(2*i-1));
else
farm{i}=FARM{Ser(2*i)};
fitness(i)=FITNESS(Ser(2*i));
end
end
%記錄最佳個體和收斂曲線
minfitness=min(fitness)
meanfitness=mean(fitness)
LC1(counter+1)=minfitness;%收斂曲線1，各代最優個體適應值的記錄
LC2(counter+1)=meanfitness;%收斂曲線2，各代群體平均適應值的記錄
pos=find(fitness==minfitness);
Xp=farm{pos(1)};
%第五步：變異
for i=1:N
if Pm>rand;%變異概率為Pm
X=farm{i};
I=unidrnd(m);
J=unidrnd(n);
X(I,J)=1+(P(J)-eps)*rand;
farm{i}=X;
end
end
farm{pos(1)}=Xp;
counter=counter+1
end
%輸出結果並繪圖
figure(1);
plotif=1;
X=Xp;
[Zp,Y1p,Y2p,Y3p]=COST(X,T,P,plotif);
figure(2);
plot(LC1);
figure(3);
plot(LC2);
⑵ 請教遺傳演算法三個問題
1、先交叉 在變異 還是先變異後交叉？
2、選擇父代進行交叉的個數是不是2n個？n是種群大小。
3、交叉概率+變異概率=100%？ 還是就沒啥關系？
可以這樣理解。一般都是順序選擇個體，逐一生成隨機數的吧。因為從選擇操作上看，種群中個體不存在序，所以沒有必要隨機選擇。
不過交叉後得到的種群還不能稱為子代。
2 不是。對於每一父代種群中個體產生一個（0，1）間的隨機數，若大於交叉概率，該個體不參與交叉。反之被標記，並於下一個參與交叉的個體進行交叉操作，所生成的兩個個體替換父代的兩個個體。因而，每一個父代個體可能參與0或1次交叉。
3 兩者不存在相加為100%的關系。這是兩種不同操作。但是取值組合確實對結果有影響。
以上是根據遺傳演算法的標准源碼給出的，你最好看看遺傳演算法的標准源碼。遺傳演算法發展至今已有很多改進的方法和新設計的運算元，性能較標准源碼有不少的提升。
⑶ 關於遺傳演算法源代碼問題
generation number和population
⑷ 遺傳演算法改進的模糊C-均值聚類MATLAB源碼範例
function [BESTX,BESTY,ALLX,ALLY]=GAFCM(K,N,Pm,LB,UB,D,c,m)
%% 此函數實現遺傳演算法，用於模糊C－均值聚類
%% 輸入參數列表
% K 迭代次數
% N 種群規模，要求是偶數
% Pm 變異概率
% LB 決策變數的下界，M×1的向量
% UB 決策變數的上界，M×1的向量
% D 原始樣本數據，n×p的矩陣
% c 分類個數
% m 模糊C均值聚類數學模型中的指數
%% 輸出參數列表
% BESTX K×1細胞結構，每一個元素是M×1向量，記錄每一代的最優個體
% BESTY K×1矩陣，記錄每一代的最優個體的評價函數值
% ALLX K×1細胞結構，每一個元素是M×N矩陣，記錄全部個體
% ALLY K×N矩陣，記錄全部個體的評價函數值
%% 第一步：
M=length(LB);%決策變數的個數
%種群初始化，每一列是一個樣本
farm=zeros(M,N);
for i=1:M
x=unifrnd(LB(i),UB(i),1,N);
farm(i,:)=x;
end
%輸出變數初始化
ALLX=cell(K,1);%細胞結構，每一個元素是M×N矩陣，記錄每一代的個體
ALLY=zeros(K,N);%K×N矩陣，記錄每一代評價函數值
BESTX=cell(K,1);%細胞結構，每一個元素是M×1向量，記錄每一代的最優個體
BESTY=zeros(K,1);%K×1矩陣，記錄每一代的最優個體的評價函數值
k=1;%迭代計數器初始化
%% 第二步：迭代過程
while k<=K
%% 以下是交叉過程
newfarm=zeros(M,2*N);
Ser=randperm(N);%兩兩隨機配對的配對表
A=farm(:,Ser(1));
B=farm(:,Ser(2));
P0=unidrnd(M-1);
a=[A(1:P0,:);B((P0+1):end,:)];%產生子代a
b=[B(1:P0,:);A((P0+1):end,:)];%產生子代b
newfarm(:,2*N-1)=a;%加入子代種群
newfarm(:,2*N)=b;???
for i=1:(N-1)
A=farm(:,Ser(i));
B=farm(:,Ser(i+1));
P0=unidrnd(M-1);
a=[A(1:P0,:);B((P0+1):end,:)];
b=[B(1:P0,:);A((P0+1):end,:)];
newfarm(:,2*i-1)=a;
newfarm(:,2*i)=b;
end
FARM=[farm,newfarm];
%% 選擇復制
SER=randperm(3*N);
FITNESS=zeros(1,3*N);
fitness=zeros(1,N);
for i=1:(3*N)
Beta=FARM(:,i);
FITNESS(i)=FIT(Beta,D,c,m);
end
for i=1:N
f1=FITNESS(SER(3*i-2));
f2=FITNESS(SER(3*i-1));
f3=FITNESS(SER(3*i));
if f1<=f2&&f1<=f3
farm(:,i)=FARM(:,SER(3*i-2));
fitness(:,i)=FITNESS(:,SER(3*i-2));
elseif f2<=f1&&f2<=f3
farm(:,i)=FARM(:,SER(3*i-1));
fitness(:,i)=FITNESS(:,SER(3*i-1));
else
farm(:,i)=FARM(:,SER(3*i));
fitness(:,i)=FITNESS(:,SER(3*i));
end
end
%% 記錄最佳個體和收斂曲線
X=farm;
Y=fitness;
ALLX{k}=X;
ALLY(k,:)=Y;
minY=min(Y);
pos=find(Y==minY);
BESTX{k}=X(:,pos(1));
BESTY(k)=minY;???
%% 變異
for i=1:N
if Pm>rand&&pos(1)~=i
AA=farm(:,i);
BB=GaussMutation(AA,LB,UB);
farm(:,i)=BB;
end
end
disp(k);
k=k+1;
end
%% 繪圖
BESTY2=BESTY;
BESTX2=BESTX;
for k=1:K
TempY=BESTY(1:k);
minTempY=min(TempY);
posY=find(TempY==minTempY);
BESTY2(k)=minTempY;
BESTX2{k}=BESTX{posY(1)};
end
BESTY=BESTY2;
BESTX=BESTX2;
plot(BESTY,'-ko','MarkerEdgeColor','k','MarkerFaceColor','k','MarkerSize',2)
ylabel('函數值')
xlabel('迭代次數')
grid on
忘記寫了，這個是源代碼！謝謝謝謝！
⑸ 急求關於資源調度的遺傳演算法源代碼，java語言
車間作業調度問題遺傳演算法 %--- % 輸入參數列表 % M 遺傳進化迭代次數 %newfarm=cell(1,N);%交叉產生的新種群存在其中 Ser=randperm(N); for i,
⑹ 請問這個MATLAB遺傳演算法源代碼應該怎樣使用
在command窗口中輸入函數名字加參數值，把括弧里的參數變成具體數後在命令窗口中輸入ga(d,termops,num,pc,cxops,pm,alpha)
⑺ 遺傳演算法的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");
}
⑻ 大家好，請問誰有基於matlab的遺傳演算法源代碼，很需要呀
function [Zp,Y1p,Y2p,Y3p,Xp,LC1,LC2]=JSPGA(M,N,Pm,T,P)
%--------------------------------------------------------------------------
% JSPGA.m
% 車間作業調度問題遺傳演算法
%--------------------------------------------------------------------------
% 輸入參數列表
% M 遺傳進化迭代次數
% N 種群規模(取偶數)
% Pm 變異概率
% T m×n的矩陣，存儲m個工件n個工序的加工時間
% P 1×n的向量，n個工序中，每一個工序所具有的機床數目
% 輸出參數列表
% Zp 最優的Makespan值
% Y1p 最優方案中，各工件各工序的開始時刻，可根據它繪出甘特圖
% Y2p 最優方案中，各工件各工序的結束時刻，可根據它繪出甘特圖
% Y3p 最優方案中，各工件各工序使用的機器編號
% Xp 最優決策變數的值，決策變數是一個實數編碼的m×n矩陣
% LC1 收斂曲線1，各代最優個體適應值的記錄
% LC2 收斂曲線2，各代群體平均適應值的記錄
% 最後，程序還將繪出三副圖片：兩條收斂曲線圖和甘特圖（各工件的調度時序圖）
%第一步：變數初始化
[m,n]=size(T);%m是總工件數，n是總工序數
Xp=zeros(m,n);%最優決策變數
LC1=zeros(1,M);%收斂曲線1
LC2=zeros(1,N);%收斂曲線2
%第二步：隨機產生初始種群
farm=cell(1,N);%採用細胞結構存儲種群
for k=1:N
X=zeros(m,n);
for j=1:n
for i=1:m
X(i,j)=1+(P(j)-eps)*rand;
end
end
farm=X;
end
counter=0;%設置迭代計數器
while counter
%第三步：交叉
newfarm=cell(1,N);%交叉產生的新種群存在其中
Ser=randperm(N);
for i=1:2:(N-1)
A=farm;%父代個體
B=farm;
Manner=unidrnd(2);%隨機選擇交叉方式
if Manner==1
cp=unidrnd(m-1);%隨機選擇交叉點
%雙親雙子單點交叉
a=[A(1:cp,:);B((cp+1):m,:)];%子代個體
b=[B(1:cp,:);A((cp+1):m,:)];
else
cp=unidrnd(n-1);%隨機選擇交叉點
a=[A(:,1:cp),B(:,(cp+1):n)];%雙親雙子單點交叉
b=[B(:,1:cp),A(:,(cp+1):n)];
end
newfarm=a;%交叉後的子代存入newfarm
newfarm=b;
end
%新舊種群合並
FARM=[farm,newfarm];
%第四步：選擇復制
FITNESS=zeros(1,2*N);
fitness=zeros(1,N);
plotif=0;
for i=1:(2*N)
X=FARM;
Z=COST(X,T,P,plotif);%調用計算費用的子函數
FITNESS(i)=Z;
end
%選擇復制採取兩兩隨機配對競爭的方式，具有保留最優個體的能力
Ser=randperm(2*N);
for i=1:N
f1=FITNESS(Ser(2*i-1));
f2=FITNESS(Ser(2*i));
if f1<=f2
farm=FARM;
fitness(i)=FITNESS(Ser(2*i-1));
else
farm=FARM;
fitness(i)=FITNESS(Ser(2*i));
end
end
%記錄最佳個體和收斂曲線
minfitness=min(fitness)
meanfitness=mean(fitness)
LC1(counter+1)=minfitness;%收斂曲線1，各代最優個體適應值的記錄
LC2(counter+1)=meanfitness;%收斂曲線2，各代群體平均適應值的記錄
pos=find(fitness==minfitness);
Xp=farm;
%第五步：變異
for i=1:N
if Pm>rand;%變異概率為Pm
X=farm;
I=unidrnd(m);
J=unidrnd(n);
X(I,J)=1+(P(J)-eps)*rand;
farm=X;
end
end
farm=Xp;
counter=counter+1
end
%輸出結果並繪圖
figure(1);
plotif=1;
X=Xp;
[Zp,Y1p,Y2p,Y3p]=COST(X,T,P,plotif);
figure(2);
plot(LC1);
figure(3);
plot(LC2);
⑼ 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
遺傳演算法
遺傳運算元
編碼
@@@需要的話按我的名字找我吧