遗传算法学习（附代码）

遗传算法的主要流程

1 函数解读

1.1 randperm

作用：随机产生一个由数字1~n组成的无重复序列
p = randperm(n) 返回行向量，其中包含从 1 到 n（包括二者）之间的整数随机置换
p = randperm(n,k) 返回行向量，其中包含在 1 到 n（包括二者）之间随机选择的 k 个唯一整数

>> randperm(6)
ans =
     6     3     5     1     2     4
>> randperm(6,3)
ans =
     1     5     6

1.2 randi

均匀分布的伪随机整数

>> randi(10,5,1)
ans =
    10
     5
     9
     2
     5
>> randi([-5,5],10,1)
ans =
     5
     3
     5
     2
    -5
     4
     5
     2
     3
     3

1.3 eliminate

expr = eliminate(eqns,vars)
消除eqns中的vars

>> syms x y
eqns = [x*y/(x-2) + y == 5/(y - x), y-x == 1/(x-1)]
eqns =
[ y + (x*y)/(x - 2) == -5/(x - y), y - x == 1/(x - 1)]
>> eliminate(eqns,x)
ans =
6*y^2 - 5*y - 75

1.4 find(x~=a)

find :查找非零值

>> x = [1 34 56 29 12 64]
x =
     1    34    56    29    12    64
>> x(find(x ~=56))
ans =
     1    34    29    12    64

1.5 round

Y = round(X) 将 X 的每个元素四舍五入为最近的整数
Y = round(X,N) 四舍五入到 N 位数：

• N > 0：舍入到小数点右侧的第 N 位数
• N = 0：四舍五入到最接近的整数
• N < 0：舍入到小数点左侧的第 N 位数

>> X = 1.2354
X =
   1.235400000000000
>> round(X)
ans =
     1
>> round(X,2)
ans =
   1.240000000000000

1.6 ceil

向正无穷舍入

>> X = [-1.9 -0.2; 5.6 7]
X =
  -1.900000000000000  -0.200000000000000
   5.600000000000000   7.000000000000000
>> ceil(X)
ans =
    -1     0
     6     7

2解决tsp问题的主要代码

2.1 初始化种群

Road=ones(SizeScale,n);%初始化路径矩阵Road()
for i=1:SizeScale
    Road(i,:)=randperm(n);%随机生成初始种群（路径矩阵）
end
iter=1;
MinestRoad_fval=ones(MaxIter,1);%初始化最短里程矩阵MinestRoad_fval()
MinestRoad_opt=ones(MaxIter,n);%初始化最短里程路径矩阵
while iter<=MaxIter  
    Dist=zeros(SizeScale,1);%初始化里程矩阵Dist，用于存储每条路径的里程值
    for i=1:SizeScale
    for j=1:(n-1)
       Dist(i)=Dist(i)+DistMatrix(Road(i,j),Road(i,j+1));
    end  
       Dist(i)=Dist(i)+DistMatrix(Road(i,1),Road(i,n));、
end 

2.2 适应度计算

fitmatrix=ones(SizeScale,1);
[MinRoad A]=min(Dist(:,1));%计算出最小里程值
MaxRoad=max(Dist(:,1)); %计算出最大里程值
for i=1:SizeScale
     fitmatrix(i)=fitness(MinRoad,MaxRoad,Dist(i));
end

2.3 选择

[c p]=sort(fitmatrix(:,1));%对适应度值进行升序排列，c中存放升序排列适应度的值，p中存放的是c对fitmatrix()的索引，即适应度值对应的fitmatrix()中的第几行
change=20;%选出适应度值最小路径数目
for i=1:change
    Road(p(i),:)=Road(p(SizeScale),:);%选出适应度值最小的20条路径，用适应度值最大的路径替换
end
Roadnew=Road;

2.4 交叉

%%%%%%%%%%%%交叉操作%%%%%%%%%%%%
for i=1:SizeScale
u=randi([1 SizeScale],2,1);
s=u(1);
t=u(2);
if rand(1)

每次操作后计算最短里程路径

Dist=zeros(SizeScale,1);
	for i=1:SizeScale
	     for j=1:(n-1)
	         Dist(i)=Dist(i)+DistMatrix(Road1(i,j),Road1(i,j+1));
	     end    
	     Dist(i)=Dist(i)+DistMatrix(Road1(i,1),Road1(i,n));
	end 
	[MinRoad2 B]=min(Dist);
	MaxRoad=max(Dist(:,1));
	for i=1:SizeScale
	    fitmatrix(i)=fitness(MinRoad2,MaxRoad,Dist(i));
	end

2.5 变异（单点交叉）

k=1;
[d p]=sort(fitmatrix(:,1));
while k<=SizeScale
	c=randi([1 n],2,1);
	pos1(1,:)=c(1,:);%随机产生交叉点
	pos2(1,:)=c(2,:);%随机产生交叉点
	rk=rand();
	if rk<=pm&&k~=p(SizeScale) %是否进行变异
		temp=Road1(p(k),pos1);
		Road1(p(k),pos1)=Road1(p(k),pos2); 
		Road1(p(k),pos2)=temp;
	end
	k=k+1;
end

2.6 最优路径

if (MinRoad2>MinRoad)&&(MinRoad3>MinRoad)
   MinestRoad=MinRoad;
   D=A;
   Road(D,:)=Road(A,:);
else
    if (MinRoad>MinRoad2)&&(MinRoad3>MinRoad2)
       MinestRoad=MinRoad2;
       D=B;
       Road(D,:)=Roadnew(B,:);
    else
        MinestRoad=MinRoad3;
        D=C;
        Road(D,:)=Road1(C,:);
    end
end
    MinestRoad_fval(iter,1)=MinestRoad;%本代最小里程值
    MinestRoad_opt(iter,:)=Road(D,:);%本代最优路径
    iter=iter+1;
    Road=Road1;
end
[MinestRoad a]=min(MinestRoad_fval);%取路径里程最小值
opt=MinestRoad_opt(a,:)%输出最优路径
fval=MinestRoad%输出最短里程
A=a   %得到最优路径的迭代次数