用遗传算法解多货郎担_2_货郎担_问题

合集下载

TSP问题求解实验报告

TSP问题求解（一）实验目的熟悉和掌握遗传算法的原理，流程和编码策略，并利用遗传求解函数优化问题，理解求解TSP问题的流程并测试主要参数对结果的影响。

（二）实验原理巡回旅行商问题给定一组n个城市和俩俩之间的直达距离，寻找一条闭合的旅程，使得每个城市刚好经过一次且总的旅行距离最短。

TSP问题也称为货郎担问题，是一个古老的问题。

最早可以追溯到1759年Euler提出的骑士旅行的问题。

1948年，由美国兰德公司推动，TSP成为近代组合优化领域的典型难题。

TSP是一个具有广泛的应用背景和重要理论价值的组合优化问题。

近年来，有很多解决该问题的较为有效的算法不断被推出，例如Hopfield神经网络方法，模拟退火方法以及遗传算法方法等。

TSP搜索空间随着城市数n的增加而增大,所有的旅程路线组合数为(n-1)!/2。

在如此庞大的搜索空间中寻求最优解，对于常规方法和现有的计算工具而言，存在着诸多计算困难。

借助遗传算法的搜索能力解决TSP问题，是很自然的想法。

基本遗传算法可定义为一个8元组：（SGA）=（C，E，P0，M，Φ，Г，Ψ，Τ）C ——个体的编码方法，SGA使用固定长度二进制符号串编码方法；E ——个体的适应度评价函数；P0——初始群体；M ——群体大小，一般取20—100；Ф——选择算子，SGA使用比例算子；Г——交叉算子，SGA使用单点交叉算子；Ψ——变异算子，SGA使用基本位变异算子；Т——算法终止条件，一般终止进化代数为100—500；问题的表示对于一个实际的待优化问题，首先需要将其表示为适合于遗传算法操作的形式。

用遗传算法解决TSP，一个旅程很自然的表示为n个城市的排列，但基于二进制编码的交叉和变异操作不能适用。

路径表示是表示旅程对应的基因编码的最自然，最简单的表示方法。

它在编码，解码，存储过程中相对容易理解和实现。

例如：旅程（5-1-7-8-9-4-6-2-3）可以直接表示为（5 1 7 8 9 4 6 2 3）（三）实验内容N>=8。

数学建模遗传算法例题

数学建模遗传算法例题数学建模中，遗传算法是一种基于进化思想的优化算法，可以应用于复杂的优化问题中。

本文将介绍一些遗传算法的例题，帮助读者更好地理解遗传算法的应用。

例题一：背包问题有一个体积为V的背包和n个物品，第i个物品的体积为vi，价值为wi。

求这个背包最多能装多少价值的物品。

遗传算法的解决步骤：1. 初始化种群：随机生成一定数量的个体作为初始种群。

2. 适应度函数：将每个个体代入适应度函数，计算其适应度值。

3. 选择：根据每个个体的适应度值，选择一定数量的个体进入下一代。

4. 交叉：对被选中的个体进行交叉操作，生成新的个体。

5. 变异：对新的个体进行变异操作，引入新的基因。

6. 重复以上步骤，直到符合终止条件。

在背包问题中，适应度函数可以定义为：背包中物品的总价值。

交叉操作可以选择单点交叉或多点交叉，变异操作可以选择随机变异或非随机变异。

例题二：旅行商问题有n个城市，旅行商需要依次经过这些城市，每个城市之间的距离已知。

求旅行商经过所有城市的最短路径。

遗传算法的解决步骤：1. 初始化种群：随机生成一定数量的个体作为初始种群，每个个体代表一种旅行路线。

2. 适应度函数：将每个个体代入适应度函数，计算其适应度值。

3. 选择：根据每个个体的适应度值，选择一定数量的个体进入下一代。

4. 交叉：对被选中的个体进行交叉操作，生成新的个体。

5. 变异：对新的个体进行变异操作，引入新的基因。

6. 重复以上步骤，直到符合终止条件。

在旅行商问题中，适应度函数可以定义为：旅行商经过所有城市的总距离。

交叉操作可以选择顺序交叉或部分映射交叉，变异操作可以选择交换或反转基因序列。

总结：遗传算法是一种强大的优化算法，可以应用于多种复杂的优化问题中。

在数学建模中，遗传算法的应用也越来越广泛。

本文介绍了背包问题和旅行商问题的遗传算法解决步骤，希望对读者有所帮助。

寻求中国货郎担问题最短回路的多项式时间算法

寻求中国货郎担问题最短回路的多项式时间算法
周培德;周忠平;张欢
【期刊名称】《北京理工大学学报》
【年(卷),期】2000(20)2
【摘要】研究求解中国货郎担问题最短回路的多项式时间算法．首先利用计算几何中凸亮与中轴的结构将点集划分成若干个子点集，然后反复采用求子点集凸壳及划分剩余干点集的方法，求得通过于点集的子路径，最后将各子路径连接成一条回路．中国货郎担问题存在多项式时间算法求得最短回路．所设计的算法的时间复杂性为O（n2lbn），将它用于中国货郎担问题，得到一条长度为15404km的最短回路．与陈沐天等人采用几何分块方法所得的最短回路相一致．
【总页数】4页(P201-204)
【关键词】中国货郎担问题;最短回路;多项式时间算法
【作者】周培德;周忠平;张欢
【作者单位】北京理工大学计算机科学与工程系
【正文语种】中文
【中图分类】O157.5;O224
【相关文献】
1.卫勤最短回路问题的遗传算法求解 [J], 蒋兴波;许开云;吴耀民
2.无回路网络中最短路问题的高效算法 [J], 冷洪泽;谢政;陈挚;徐桢
3.欧氏空间货郎担问题的一个多项式时间近似方案的改进与实现 [J], 赵卫中;冯好
娣;朱大铭
4.用遗传算法解多货郎担(2-货郎担)问题 [J], 杜均;蔡之华;陈云亮;朱莉
5.货郎担问题的对角线生成和2—最优改进回路解法 [J], King.,J;张小萸
因版权原因，仅展示原文概要，查看原文内容请购买。

基于并行遗传算法多旅行商问题的求解

Microcomputer Applications V ol.27,No.7,2011开发应用微型电脑应用2011年第27卷第7期5文章编号：1007-757X(2011)07-0045-03基于并行遗传算法多旅行商问题的求解吴云，姜麟，刘强摘要：以往求解多旅行商问题的研究仅局限于以各旅行商路程总和最小为优化标准的传统遗传算法，而没有考虑他们的速度和所花时间。

在MPI 并行环境下，用C++语言实现了粗粒度模型的并行遗传算法。

结合并行遗传算法的特点，提出了解决多旅行商问题的策略以及给出相应的算法过程，并进行了有效验证。

通过研究结果表明，与传统遗传算法相比，并行遗传算法提高了运算速度，降低了平均开销时间并且最小总路径值更理想。

关键词：并行遗传算法；多旅行商问题；消息传递中图分类号：CN 31-1634/TP 文献标志码：A0引言旅行商问题(Traveling Salesman Problem,简称TSP)，又称为货郎担问题，这是一个古老而又困难的问题，至今尚未彻底解决。

经过几十年的发展TSP 取得了一些显著成果，除了经典旅行商问题外还引申出它的扩展形式：多旅行商问题(Multiple Traveling Salesman Problem ，简称MTSP)。

多旅行商问题就是有N 个城市，M 个旅行商从同一城市(或不同城市)出发，访问所有城市，使得每个城市有且仅有一个旅行商经过(出发城市除外)，且总旅行路程最短。

近年来MTSP 问题已经吸引了大量的研究者和探索者。

它是一个典型、易描述却难处理的NP 组合优化问题[1]，组合优化是遗传算法最基本的研究应用领域之一。

遗传算法是一种基于自然选择和群体遗传进化机理的随机搜索迭代算法，具有良好的全局寻优能力。

以往求解旅行商问题只考虑总路程和最短，而没有考虑所花时间。

本文结合并行优化方法，以便确定各个旅行商的行走路线使所花时间更小速度更快路径最短。

1多旅行商问题的数学描述多旅行商问题实际上就是寻找加权图中的最短回路问题。

遗传算法的经典案例

题目：通信网络链路容量和流量优化遗传算法MATLAB源码function [Zp,Xp,Yp,LC1,LC2]=GACFA(M,N,Pm)%--------------------------------------------------------------------------% GACFA.m% Genetic Algorithm for Capacity and Flow Assignment% 链路容量和流量优化分配的遗传算法% GreenSim团队原创作品，转载请注明% 更多原创代码，请访问GreenSim团队主页：/greensim% 算法设计、代写程序，欢迎访问GreenSim——算法仿真团队→/greensim%--------------------------------------------------------------------------% 函数功能% 使用遗传算法求解通信网链路容量和流量联合优化分配问题%--------------------------------------------------------------------------% 参考文献% 叶大振,吴新余.基于遗传算法的计算机通信网优化设计[J].% 南京邮电学院学报.1996,16(2):9-15%--------------------------------------------------------------------------% 输入参数列表% M 遗传进化迭代次数% N 种群规模(取偶数)% Pm 变异概率%--------------------------------------------------------------------------% 输出参数列表% Zp 目标函数最优值% Xp 路由选择决策变量最优值% Yp 线路型号决策变量最优值% LC1 收敛曲线1，各代最优个体适应值的记录% LC2 收敛曲线2，各代群体平均适应值的记录%--------------------------------------------------------------------------%第一步：载入数据和输出变量初始化load DATA_CFA;Xp=zeros(14,1);Yp=zeros(8,3);LC1=zeros(1,M);LC2=LC1;%第二步：随机产生初始种群farm_X=zeros(14,N);farm_Y=zeros(8,3*N);for i=1:Nfor j=1:2:13RAND=rand;if RAND>0.5farm_X(j,i)=1;elsefarm_X(j+1,i)=1;endendendfor i=1:Nfor j=1:8RAND=rand;if RAND<1/3farm_Y(j,3*i-2)=1;elseif RAND>2/3farm_Y(j,3*i)=1;elsefarm_Y(j,3*i-1)=1;endendendcounter=0;%设置迭代计数器while counter<M%停止条件为达到最大迭代次数%第三步：交叉newfarm_X=zeros(14,N);newfarm_Y=zeros(8,3*N);Ser=randperm(N);%对X做交叉for i=1:2:(N-1)A_X=farm_X(:,Ser(i));B_X=farm_X(:,Ser(i+1));cp=2*unidrnd(6);a_X=[A_X(1:cp);B_X((cp+1):end)];b_X=[B_X(1:cp);A_X((cp+1):end)];newfarm_X(:,i)=a_X;newfarm_X(:,i+1)=b_X;end%对Y做交叉for i=1:2:(N-1)A_Y=farm_Y(:,(3*Ser(i)-2):(3*Ser(i)));B_Y=farm_Y(:,(3*Ser(i+1)-2):(3*Ser(i+1))); cp=unidrnd(7);a_Y=[A_Y(1:cp,:);B_Y((cp+1):end,:)];b_Y=[B_Y(1:cp,:);A_Y((cp+1):end,:)];newfarm_Y(:,(3*i-2):(3*i))=a_Y;newfarm_Y(:,(3*i+1):(3*i+3))=b_Y;end%新旧种群合并FARM_X=[farm_X,newfarm_X];FARM_Y=[farm_Y,newfarm_Y];%第四步：选择复制Ser=randperm(2*N);FITNESS=zeros(1,2*N);fitness=zeros(1,N);for i=1:(2*N)X=FARM_X(:,i);Y=FARM_Y(:,(3*i-2):(3*i));FITNESS(i)=COST(X,Y,x1_x14,F_x1_x14,A,Q,C,S,b);endfor i=1:Nf1=FITNESS(Ser(2*i-1));f2=FITNESS(Ser(2*i));if f1<f2farm_X(:,i)=FARM_X(:,Ser(2*i-1));farm_Y(:,(3*i-2):(3*i))=FARM_Y(:,(3*Ser(2*i-1)-2):(3*Ser(2*i-1))); fitness(i)=f1;elsefarm_X(:,i)=FARM_X(:,Ser(2*i));farm_Y(:,(3*i-2):(3*i))=FARM_Y(:,(3*Ser(2*i)-2):(3*Ser(2*i)));fitness(i)=f2;endend%记录最佳个体和收敛曲线minfitness=min(fitness);meanfitness=mean(fitness);LC1(counter+1)=minfitness;LC2(counter+1)=meanfitness;pos=find(fitness==minfitness);Xp=farm_X(:,pos(1));Yp=farm_Y(:,(3*pos(1)-2):(3*pos(1)));Zp=minfitness;%第五步：变异for i=1:Nif Pm>randGT_X=farm_X(:,i);GT_Y=farm_Y(:,(3*i-2):(3*i));pos1=2*unidrnd(7);if GT_X(pos1)==1GT_X(pos1-1)=1;GT_X(pos1)=0;farm_X(:,i)=GT_X;elseif GT_X(pos1)==0GT_X(pos1-1)=0;GT_X(pos1)=1;farm_X(:,i)=GT_X;elseendpos2=unidrnd(8);GT_Y(pos2,:)=zeros(1,3);GT_Y(pos2,unidrnd(3))=1;endendcounter=counter+1endXp=Xp';Yp=Yp';%plot(LC1)%hold onplot(LC2)遗传算法程序:说明: fga.m 为遗传算法的主程序; 采用二进制Gray编码,采用基于轮盘赌法的非线性排名选择, 均匀交叉,变异操作,而且还引入了倒位操作!function[BestPop,Trace]=fga(FUN,LB,UB,eranum,popsize,pCross,pMutation,pInversion,options)% [BestPop,Trace]=fmaxga(FUN,LB,UB,eranum,popsize,pcross,pmutation)% Finds a maximum of a function of several variables.% fmaxga solves problems of the form:% max F(X) subject to: LB <= X <= UB% BestPop - 最优的群体即为最优的染色体群% Trace - 最佳染色体所对应的目标函数值% FUN - 目标函数% LB - 自变量下限% UB - 自变量上限% eranum - 种群的代数,取100--1000(默认200)% popsize - 每一代种群的规模；此可取50--200(默认100)% pcross - 交叉概率,一般取0.5--0.85之间较好(默认0.8)% pmutation - 初始变异概率,一般取0.05-0.2之间较好(默认0.1)% pInversion - 倒位概率,一般取0.05－0.3之间较好(默认0.2)% options - 1*2矩阵,options(1)=0二进制编码(默认0),option(1)~=0十进制编%码,option(2)设定求解精度(默认1e-4)%% ------------------------------------------------------------------------T1=clock;if nargin<3, error('FMAXGA requires at least three input arguments'); endif nargin==3,eranum=200;popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==4, popsize=100;pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];end if nargin==5, pCross=0.8;pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==6, pMutation=0.1;pInversion=0.15;options=[0 1e-4];endif nargin==7, pInversion=0.15;options=[0 1e-4];endif find((LB-UB)>0)error('数据输入错误,请重新输入(LB<UB):');ends=sprintf('程序运行需要约%.4f 秒钟时间,请稍等......',(eranum*popsize/1000));disp(s);global m n NewPop children1 children2 VarNumbounds=[LB;UB]';bits=[];VarNum=size(bounds,1);precision=options(2);%由求解精度确定二进制编码长度bits=ceil(log2((bounds(:,2)-bounds(:,1))' ./ precision));%由设定精度划分区间[Pop]=InitPopGray(popsize,bits);%初始化种群[m,n]=size(Pop);NewPop=zeros(m,n);children1=zeros(1,n);children2=zeros(1,n);pm0=pMutation;BestPop=zeros(eranum,n);%分配初始解空间BestPop,TraceTrace=zeros(eranum,length(bits)+1);i=1;while i<=eranumfor j=1:mvalue(j)=feval(FUN(1,:),(b2f(Pop(j,:),bounds,bits)));%计算适应度end[MaxValue,Index]=max(value);BestPop(i,:)=Pop(Index,:);Trace(i,1)=MaxValue;Trace(i,(2:length(bits)+1))=b2f(BestPop(i,:),bounds,bits);[selectpop]=NonlinearRankSelect(FUN,Pop,bounds,bits);%非线性排名选择[CrossOverPop]=CrossOver(selectpop,pCross,round(unidrnd(eranum-i)/eranum));%采用多点交叉和均匀交叉，且逐步增大均匀交叉的概率%round(unidrnd(eranum-i)/eranum)[MutationPop]=Mutation(CrossOverPop,pMutation,VarNum);%变异[InversionPop]=Inversion(MutationPop,pInversion);%倒位Pop=InversionPop;%更新pMutation=pm0+(i^4)*(pCross/3-pm0)/(eranum^4);%随着种群向前进化，逐步增大变异率至1/2交叉率p(i)=pMutation;i=i+1;endt=1:eranum;plot(t,Trace(:,1)');title('函数优化的遗传算法');xlabel('进化世代数(eranum)');ylabel('每一代最优适应度(maxfitness)');[MaxFval,I]=max(Trace(:,1));X=Trace(I,(2:length(bits)+1));hold on; plot(I,MaxFval,'*');text(I+5,MaxFval,['FMAX=' num2str(MaxFval)]);str1=sprintf('进化到 %d 代 ,自变量为 %s 时,得本次求解的最优值 %f\n对应染色体是：%s',I,num2str(X),MaxFval,num2str(BestPop(I,:)));disp(str1);%figure(2);plot(t,p);%绘制变异值增大过程T2=clock;elapsed_time=T2-T1;if elapsed_time(6)<0elapsed_time(6)=elapsed_time(6)+60; elapsed_time(5)=elapsed_time(5)-1;endif elapsed_time(5)<0elapsed_time(5)=elapsed_time(5)+60;elapsed_time(4)=elapsed_time(4)-1;end %像这种程序当然不考虑运行上小时啦str2=sprintf('程序运行耗时 %d 小时 %d 分钟 %.4f 秒',elapsed_time(4),elapsed_time(5),elapsed_time(6));disp(str2);TSP问题遗传算法matlab源程序（注释详细，经反复实验收敛速度快）%TSP问题（又名：旅行商问题，货郎担问题）遗传算法通用matlab程序%D是距离矩阵，n为种群个数,建议取为城市个数的1~2倍，%C为停止代数，遗传到第 C代时程序停止,C的具体取值视问题的规模和耗费的时间而定%m为适应值归一化淘汰加速指数 ,最好取为1,2,3,4 ,不宜太大%alpha为淘汰保护指数,可取为0~1之间任意小数,取1时关闭保护功能,最好取为0.8~1.0%R为最短路径,Rlength为路径长度function [R,Rlength]=geneticTSP(D,n,C,m,alpha)[N,NN]=size(D);farm=zeros(n,N);%用于存储种群for i=1:nfarm(i,=randperm(N);%随机生成初始种群endR=farm(1,;%存储最优种群len=zeros(n,1);%存储路径长度fitness=zeros(n,1);%存储归一化适应值counter=0;while counter<Cfor i=1:nlen(i,1)=myLength(D,farm(i,);%计算路径长度endmaxlen=max(len);minlen=min(len);fitness=fit(len,m,maxlen,minlen);%计算归一化适应值 rr=find(len==minlen);R=farm(rr(1,1),;%更新最短路径FARM=farm;%优胜劣汰，nn记录了复制的个数nn=0;for i=1:nif fitness(i,1)>=alpha*randnn=nn+1;FARM(nn,=farm(i,;endendFARM=FARM(1:nn,;[aa,bb]=size(FARM);%交叉和变异while aa<nif nn<=2nnper=randperm(2);elsennper=randperm(nn);endA=FARM(nnper(1),;B=FARM(nnper(2),;[A,B]=intercross(A,B);FARM=[FARM;A;B];[aa,bb]=size(FARM);endif aa>nFARM=FARM(1:n,;%保持种群规模为nendfarm=FARM;clear FARMcounter=counter+1endRlength=myLength(D,R);function [a,b]=intercross(a,b)L=length(a);if L<=10%确定交叉宽度W=1;elseif ((L/10)-floor(L/10))>=rand&&L>10W=ceil(L/10);elseW=floor(L/10);endp=unidrnd(L-W+1);%随机选择交叉范围，从p到p+Wfor i=1:W%交叉x=find(a==b(1,p+i-1));y=find(b==a(1,p+i-1));[a(1,p+i-1),b(1,p+i-1)]=exchange(a(1,p+i-1),b(1,p+i-1));[a(1,x),b(1,y)]=exchange(a(1,x),b(1,y));endfunction [x,y]=exchange(x,y)temp=x;x=y;y=temp;% 计算路径的子程序function len=myLength(D,p)[N,NN]=size(D);len=D(p(1,N),p(1,1));for i=1N-1)len=len+D(p(1,i),p(1,i+1));end%计算归一化适应值子程序function fitness=fit(len,m,maxlen,minlen)fitness=len;for i=1:length(len)fitness(i,1)=(1-((len(i,1)-minlen)/(maxlen-minlen+0.000001))).^m; end%初始化种群%采用二进制Gray编码,其目的是为了克服二进制编码的Hamming悬崖缺点function [initpop]=InitPopGray(popsize,bits)len=sum(bits);initpop=zeros(popsize,len);%The whole zero encoding individualfor i=2:popsize-1pop=round(rand(1,len));pop=mod(([0 pop]+[pop 0]),2);%i=1时,b(1)=a(1);i>1时,b(i)=mod(a(i-1)+a(i),2)%其中原二进制串:a(1)a(2)...a(n),Gray串:b(1)b(2)...b(n)initpop(i,:)=pop(1:end-1);endinitpop(popsize,:)=ones(1,len);%The whole one encoding individual%解码function [fval] = b2f(bval,bounds,bits)% fval - 表征各变量的十进制数% bval - 表征各变量的二进制编码串% bounds - 各变量的取值范围% bits - 各变量的二进制编码长度scale=(bounds(:,2)-bounds(:,1))'./(2.^bits-1); %The range of the variablesnumV=size(bounds,1);cs=[0 cumsum(bits)];for i=1:numVa=bval((cs(i)+1):cs(i+1));fval(i)=sum(2.^(size(a,2)-1:-1:0).*a)*scale(i)+bounds(i,1);end%选择操作%采用基于轮盘赌法的非线性排名选择%各个体成员按适应值从大到小分配选择概率：%P(i)=(q/1-(1-q)^n)*(1-q)^i, 其中 P(0)>P(1)>...>P(n), sum(P(i))=1function [selectpop]=NonlinearRankSelect(FUN,pop,bounds,bits)global m nselectpop=zeros(m,n);fit=zeros(m,1);for i=1:mfit(i)=feval(FUN(1,:),(b2f(pop(i,:),bounds,bits)));%以函数值为适应值做排名依据endselectprob=fit/sum(fit);%计算各个体相对适应度(0,1)q=max(selectprob);%选择最优的概率x=zeros(m,2);x(:,1)=[m:-1:1]';[y x(:,2)]=sort(selectprob);r=q/(1-(1-q)^m);%标准分布基值newfit(x(:,2))=r*(1-q).^(x(:,1)-1);%生成选择概率newfit=cumsum(newfit);%计算各选择概率之和rNums=sort(rand(m,1));fitIn=1;newIn=1;while newIn<=mif rNums(newIn)<newfit(fitIn)selectpop(newIn,:)=pop(fitIn,:);newIn=newIn+1;elsefitIn=fitIn+1;endend%交叉操作function [NewPop]=CrossOver(OldPop,pCross,opts)%OldPop为父代种群，pcross为交叉概率global m n NewPopr=rand(1,m);y1=find(r<pCross);y2=find(r>=pCross);len=length(y1);if len>2&mod(len,2)==1%如果用来进行交叉的染色体的条数为奇数，将其调整为偶数y2(length(y2)+1)=y1(len);y1(len)=[];endif length(y1)>=2for i=0:2:length(y1)-2if opts==0[NewPop(y1(i+1),:),NewPop(y1(i+2),:)]=EqualCrossOver(OldPop(y1(i+1),:),OldPop(y1(i+2), :));else[NewPop(y1(i+1),:),NewPop(y1(i+2),:)]=MultiPointCross(OldPop(y1(i+1),:),OldPop(y1(i+2) ,:));endendendNewPop(y2,:)=OldPop(y2,:);%采用均匀交叉function [children1,children2]=EqualCrossOver(parent1,parent2)global n children1 children2hidecode=round(rand(1,n));%随机生成掩码crossposition=find(hidecode==1);holdposition=find(hidecode==0);children1(crossposition)=parent1(crossposition);%掩码为1，父1为子1提供基因children1(holdposition)=parent2(holdposition);%掩码为0，父2为子1提供基因children2(crossposition)=parent2(crossposition);%掩码为1，父2为子2提供基因children2(holdposition)=parent1(holdposition);%掩码为0，父1为子2提供基因%采用多点交叉，交叉点数由变量数决定function [Children1,Children2]=MultiPointCross(Parent1,Parent2)global n Children1 Children2 VarNumChildren1=Parent1;Children2=Parent2;Points=sort(unidrnd(n,1,2*VarNum));for i=1:VarNumChildren1(Points(2*i-1):Points(2*i))=Parent2(Points(2*i-1):Points(2*i));Children2(Points(2*i-1):Points(2*i))=Parent1(Points(2*i-1):Points(2*i));end%变异操作function [NewPop]=Mutation(OldPop,pMutation,VarNum)global m n NewPopr=rand(1,m);position=find(r<=pMutation);len=length(position);if len>=1for i=1:lenk=unidrnd(n,1,VarNum); %设置变异点数，一般设置1点for j=1:length(k)if OldPop(position(i),k(j))==1OldPop(position(i),k(j))=0;elseOldPop(position(i),k(j))=1;endendendendNewPop=OldPop;%倒位操作function [NewPop]=Inversion(OldPop,pInversion)global m n NewPopNewPop=OldPop;r=rand(1,m);PopIn=find(r<=pInversion);len=length(PopIn);if len>=1for i=1:lend=sort(unidrnd(n,1,2));if d(1)~=1&d(2)~=nNewPop(PopIn(i),1:d(1)-1)=OldPop(PopIn(i),1:d(1)-1);NewPop(PopIn(i),d(1):d(2))=OldPop(PopIn(i),d(2):-1:d(1)); NewPop(PopIn(i),d(2)+1:n)=OldPop(PopIn(i),d(2)+1:n);endendend。

遗传算法解决TSP问题

个），用两点交叉算子进行操作。例如对于下面两个染色体个体
（1 3 4 | 5 2 9 | 8 6 7）（1 7 6 | 9 5 2 | 4 3 8）
通过两点交叉可得到子代染色体为（1 3 4 | 9 5 2| 8 6 7）（1 7 6 | 5 2 9 | 4 3 8）
遗传算法解决TSP问题（二）
遗传算法解决TSP问题（二）
用交概率Pc,变异概率Pm.
(1)生成原始染色体种群
采用实数编码，以N个城市的序号作为一条可能的
路径。
例如对8个城市，可生成如下的染色体
代表一条路径，8,6,4,2,7,5,3,1.重复操作生成数目等
于n的染色体种群。
遗传算法解决TSP问题（二）
实际编程（采用48城市数据集，最优解10628）
1 .遗传变量
遗传算法解决TSP问题（三）
2.遗传方法
遗传算法解决TSP问题（三）
3 运行截图
遗传算法解决TSP问题（三）
遗传算法解决TSP问题（三）
谢谢观看
遗传算法解决TSP问题Algorithm）是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。遗传算法是从代表问题可能潜在的解集的一个种群（population）开始的，而一个种群则由经过基因（gene）编码的一定数目的个体(individual)组成。每个个体实际上是染色体(chromosome)带有特征的实体。染色体作为遗传物质的主要载体，即多个基因的集合，其内部表现（即基因型）是某种基因组合，它决定了个体的形状的外部表现，如黑头发的特征是由染色体中控制这一特征的某种基因组合决定的。因此，在一开始需要实现从表现型到基因型的映射即编码工作。由于仿照基因编码的工作很复杂，我们往往进行简化，如二进制编码，初代种群产生之后，按照适者生存和优胜劣汰的原理，逐代（generation）演化产生出越来越好的近似解，在每一代，根据问题域中个体的适应度（fitness）大小选择（selection）个体，并借助于自然遗传学的遗传算子（genetic operators）进行组合交叉（crossover）和变异（mutation），产生出代表新的解集的种群。这个过程将导致种群像自然进化一样的后生代种群比前代更加适应于环境，末代种群中的最优个体经过解码（decoding），可以作为问题近似最优解。

应用改进的遗传算法求解TSP问题

ＢａｅｎｉｒｖｄｇｎｔｌｏｉｍｒＰｓｄｏｍｐｏｅｅｅｉａｇｒｔｆｃｈｏＴＳ
ＨＵＡＮＧｏｇｊｎＷＵｏ —ｉ．ＬＵａｂｎＹｎ－．ｕＹｕｘｎＩＨｕ —ｉ
（ｐｒｎｆｍｐｔｒｃｅｃｎｅｈｏｏｙｃｏｌｆｎｏｍａｉｎＥｇｎｅｉｇＮａｃａｇＵｎｖｒｉ，ＤｅａｔｔｍｅｏＣｏｕｅｉｎｅａｄＴｃｎｌｇ，Ｓｈｏｆｒｔｎｉｅｒ，ｎｈｎｉｅｓｔＳｏＩｏｎｙ
ａｏｔｍ，ｈｃｃｌａｅｎｅｇｎｅｂｌ￣ｎｅｔｉｎｐｒｔｒｄａｉｌｍｕｔｎｒｂｂｌｙｏｉｉｅｉｅｓｌｒｈｗｉｈｃｅｒｔｓｏｖｒｅｃ，ｙｍｐｏｇｈａｏｅａｏｒｂｅｔｉｏａｉｔｎｎｔｖｒｔｇｉａｅｃｅｔｍｕｔｏｎａｖａａｏｐｉｔｍａｔｈｄａｉｙ
的遗传算法，明该算法具有良好的有效性和可行性说
关键词：旅行商问题；组合优化；遗传算法；启发式交叉算子；可变概率
中图法分类号：Ｐ０，Ｔ３１６文献标识码：Ａ文章编号：００７２２０）４５０．３１０．０４（０７２．９９０
ｉｓｐｒｏｅｔｄｔｎｌｅｅｉｌｏｔｄｈｓｏｄｖｌｉｄｆａｉｉｔ．ｓｕｅｒｏｔａｉｏａｎｔａｇｒｈａａｏａｉｔａｅｓｌｉｔｈｒｉｇｃｉｍｎｇｄｙｎｂｉｙＫｅｒｓＴＰｃｍｂｎｔｎｏｔｍ；ＧＡ；ｈｕｉｔｒｓｏｅｐｒｔｒｖｒａｌｒｂｂｌｙｗｏｄ：Ｓ；ｏｉａｉｐｉｏｍｕｅｒｓｉｃｏｓｖｒｅａｏ；ａｉｂｅｐｏａｉｔｃｏｉｙ

算法分支限界法货郎担问题解法

标题：算法分支限界法在货郎担问题中的应用摘要：分支限界法是一种高效的解决组合优化问题的算法，本文将详细介绍分支限界法在货郎担问题中的应用，包括问题的描述、算法原理、实现步骤以及案例分析等内容。

一、问题描述货郎担问题，又称为旅行商问题（TSP），是一个经典的组合优化问题。

问题的描述为：有n个城市，货郎担需要从一个城市出发，经过所有的城市且只经过一次，最后回到出发的城市，要求找到一条最短的路径。

这是一个NP-hard问题，传统的穷举法在城市数量较大时难以找到最优解。

二、算法原理分支限界法是一种以深度优先搜索为基础的优化算法。

其核心思想是根据当前问题状态的下界（或上界）对搜索空间进行剪枝，从而减少搜索空间，提高搜索效率。

在货郎担问题中，分支限界法通过动态规划的方式记录已经访问过的城市，从而避免重复计算，同时利用启发式信息（如最近邻居、最小生成树等）进行路径选择，不断更新路径的下界，直至找到最优解或者搜索空间被完全剪枝。

三、实现步骤1. 初始化：设置初始的城市路径、已访问城市集合、路径长度、下界等参数。

2. 搜索：利用深度优先搜索，根据当前路径确定下一个访问的城市，并更新路径长度和下界。

3. 剪枝：根据当前路径长度与下界的关系，对搜索空间进行剪枝。

4. 回溯：如果搜索路径无法继续扩展，进行回溯，更新路径状态。

5. 结束条件：当所有城市都被访问过一次后，得到一条完整的路径，更新最优解。

四、案例分析假设有5个城市，它们的坐标为：A(0, 0)、B(1, 2)、C(3, 1)、D(5, 3)、E(4, 0)利用分支限界法求解货郎担问题，我们按照以下步骤进行计算：（1）初始化：选择一个城市作为出发点，并初始化已访问城市集合、路径长度和下界。

（2）搜索：根据当前路径选择下一个访问的城市，并更新路径长度和下界。

（3）剪枝：根据当前路径长度与下界的关系，进行搜索空间的剪枝。

（4）回溯：如果搜索路径无法继续扩展，进行回溯，更新路径状态。

如何使用遗传算法解决实际问题

如何使用遗传算法解决实际问题遗传算法是一种模拟自然选择和遗传机制的优化算法，它通过模拟生物进化过程中的遗传、交叉和变异等操作，来搜索最优解。

在实际问题中，遗传算法被广泛应用于解决各种复杂的优化问题。

本文将介绍如何使用遗传算法解决实际问题，并探讨其优点和局限性。

首先，遗传算法的基本原理是模拟自然界的进化过程。

它通过对候选解进行编码，构建一个初始种群，并通过遗传操作（交叉、变异）生成新的种群，然后根据适应度函数评估每个个体的适应度，再根据适应度选择优秀的个体进行下一代的繁殖。

这个过程不断迭代，直到找到满足要求的解。

在实际问题中，遗传算法可以应用于多个领域。

例如，在工程设计中，我们可以利用遗传算法来寻找最优的设计参数，以达到最佳性能。

在物流规划中，遗传算法可以用于优化路径和运输成本，提高物流效率。

在机器学习中，遗传算法可以应用于优化神经网络的权重和结构，提高模型的性能。

遗传算法的优点之一是它能够在大规模问题中找到较好的解。

由于遗传算法的并行性和随机性，它可以在搜索空间中同时探索多个解，并通过自然选择和遗传操作不断优化解。

这使得遗传算法在处理复杂问题时具有较强的鲁棒性和全局搜索能力。

另一个优点是遗传算法的灵活性。

通过合理设计编码和适应度函数，我们可以根据问题的特点和需求来调整算法的参数和操作。

例如，在优化问题中，可以选择不同的交叉和变异策略，以及适应度函数的定义，来适应不同的目标和约束条件。

然而，遗传算法也存在一些局限性。

首先，遗传算法是一种启发式算法，它依赖于问题的特征和编码方式来搜索解空间。

如果问题的特征不符合遗传算法的假设，或者编码方式选择不当，可能会导致算法陷入局部最优解，而无法找到全局最优解。

其次，遗传算法的计算复杂度较高。

由于遗传算法需要对大量的个体进行遗传操作和适应度评估，因此在处理大规模问题时，算法的运行时间会较长。

此外，由于遗传算法是一种随机搜索算法，其收敛性和稳定性也受到随机性的影响。

遗传算法求解多目标优化问题

遗传算法求解多目标优化问题随着科技的发展和社会的进步，人们对各种问题的优化需求越来越高。

在现实生活中，我们常常面临多个目标之间的冲突，需要找到一种解决方案，能够在多个目标之间取得平衡。

在这种情况下，多目标优化问题应运而生。

多目标优化问题（Multi-Objective Optimization Problem，简称MOP）是指在具有多个冲突目标的复杂系统中寻找最优解的问题。

解决MOP问题的方法有很多种，其中一种被广泛应用的方法就是遗传算法。

遗传算法是一个基于自然进化过程的优化算法，通过模拟自然进化的过程来搜索最优解。

它将问题的解表示为一个个体（也称为染色体），通过交叉和变异等遗传操作产生下一代的个体，不断迭代，最终找到较好的解。

在使用遗传算法求解多目标优化问题时，需要采取一些特定的策略和算子来克服多目标之间的冲突。

下面我将介绍一些常见的策略和算子。

第一，适应度函数的设计。

在单目标优化问题中，适应度函数往往只有一个目标。

而在多目标优化问题中，适应度函数需要同时考虑多个目标的性能。

常用的适应度函数设计方法有线性加权和Chebyshev方法。

线性加权方法将各个目标按一定权重加权求和，而Chebyshev方法则选取各个目标值中最大的值作为适应度值。

第二，选择操作的策略。

在遗传算法中，选择操作是保留适应度较高的个体，淘汰适应度较低的个体。

针对多目标优化问题，常用的选择操作策略有非支配排序和拥挤度算子。

非支配排序方法将个体划分为不同的层级，每一层级的个体相对于其他层级的个体来说都是非支配的。

拥挤度算子则是通过计算个体在解空间中的密度来保留具有多样性的解。

第三，交叉和变异操作的设计。

在多目标优化问题中，交叉和变异操作需要保证生成的新个体能够在多个目标之间取得平衡。

常用的交叉操作有模拟二进制交叉（SBX）和离散型交叉。

SBX方法通过对父代染色体的值进行交叉，产生子代染色体的值。

离散型交叉则从父代染色体中随机选择一个目标值来构建子代染色体。

货郎担问题求解算法探讨

・
７・９
维普资讯
上接第７９页）中不可能有两条边与顶点ｃ或ｃ相关联，脚跟，而且为公司实现持续发展开辟了广阔的道路。从培（育核心竞争力入手，他们树立与市场相适应经营理念，制则在该旅游中一定包含边（，。ｃｃ）定市场开发战略、质量效益型经营战略、多元化发展战
（）２在剩下的边中找出最短边（，Ｃ）（Ｃ）ｃ，、Ｃ，，它们任意两城市之间的边按字典顺序排列：（，Ｃ）（，Ｃ）Ｃ，。，Ｃ，，
（）考虑边（ｃ）（。ｃ）３ｃ和ｃ，。，其长度为４，在剩下的
作者简介：徐海波（９８）１７－，山东财学院助教，在职研究生．
用贪心技术和分枝定界技术来求解货郎问题的一个具体实例，并用图示的方式给出这两种算法的求解过程。关键词：货郎担问题；贪心算法；分枝定界
中图分类号：Ｔ３１Ｐ１文献标识码：Ａ文章编号：１０ — ５０（０８４０７— ２８７４２０）０— ０９００
为：给定城市集合＝（ｃ， … ，ｃ）ｃ， … ．和任意两个城，市ｃ，ｃ１≤ ｊ≤ Ｊ≤ ｎ，（）间的距离ｄ度最短。
不能选取。
（）考虑边（ｃ）４ｃ，其长度５是剩下的边中最短的，（）考虑边（，ｃ）（ｃ）５Ｃ，和ｃ，，其长度均为６，但（ｃ，
，
求解货Ｂ问题贪心算法的基本思想是，连续的边选择最优解。形成货郎旅游，优先选择可形成货郎旅游的最短边。每次选择边的规则为：

TSP遗传算法

%TSP问题（又名：旅行商问题，货郎担问题）遗传算法通用matlab程序%D是距离矩阵，n为种群个数,建议取为城市个数的1~2倍，%C为停止代数，遗传到第C代时程序停止,C的具体取值视问题的规模和耗费的时间而定%m为适应值归一化淘汰加速指数,最好取为1,2,3,4 ,不宜太大%alpha为淘汰保护指数,可取为0~1之间任意小数,取1时关闭保护功能,最好取为0.8~1.0 %R为最短路径,Rlength为路径长度function [R,Rlength]=geneticTSP(D,n,C,m,alpha)[N,NN]=size(D);farm=zeros(n,N);%用于存储种群for i=1:nfarm(i,:)=randperm(N);%随机生成初始种群endR=farm(1,:);%存储最优种群len=zeros(n,1);%存储路径长度fitness=zeros(n,1);%存储归一化适应值counter=0;while counter<Cfor i=1:nlen(i,1)=myLength(D,farm(i,:));%计算路径长度endmaxlen=max(len);minlen=min(len);fitness=fit(len,m,maxlen,minlen);%计算归一化适应值rr=find(len==minlen);R=farm(rr(1,1),:);%更新最短路径FARM=farm;%优胜劣汰，nn记录了复制的个数nn=0;for i=1:nif fitness(i,1)>=alpha*randnn=nn+1;FARM(nn,:)=farm(i,:);endendFARM=FARM(1:nn,:);[aa,bb]=size(FARM);%交叉和变异while aa<nif nn<=2nnper=randperm(2);elsennper=randperm(nn);endA=FARM(nnper(1),:);B=FARM(nnper(2),:);[A,B]=intercross(A,B);FARM=[FARM;A;B];[aa,bb]=size(FARM);endif aa>nFARM=FARM(1:n,:);%保持种群规模为nendfarm=FARM;clear FARMcounter=counter+1endRlength=myLength(D,R);function [a,b]=intercross(a,b)L=length(a);if L<=10%确定交叉宽度W=1;elseif ((L/10)-floor(L/10))>=rand&&L>10W=ceil(L/10);elseW=floor(L/10);endp=unidrnd(L-W+1);%随机选择交叉范围，从p到p+W for i=1:W%交叉x=find(a==b(1,p+i-1));y=find(b==a(1,p+i-1));[a(1,p+i-1),b(1,p+i-1)]=exchange(a(1,p+i-1),b(1,p+i-1)); [a(1,x),b(1,y)]=exchange(a(1,x),b(1,y));endfunction [x,y]=exchange(x,y)temp=x;x=y;y=temp;% 计算路径的子程序function len=myLength(D,p)[N,NN]=size(D);len=D(p(1,N),p(1,1));for i=1:(N-1)len=len+D(p(1,i),p(1,i+1));end%计算归一化适应值子程序function fitness=fit(len,m,maxlen,minlen)fitness=len;for i=1:length(len)fitness(i,1)=(1-((len(i,1)-minlen)/(maxlen-minlen+0.000001))).^m; end一个C++的程序：//c++的程序#include<iostream.h>#include<stdlib.h>template<class T>class Graph{public:Graph(int vertices=10){n=vertices;e=0;}~Graph(){}virtual bool Add(int u,int v,const T& w)=0;virtual bool Delete(int u,int v)=0;virtual bool Exist(int u,int v)const=0;int Vertices()const{return n;}int Edges()const{return e;}protected:int n;int e;};template<class T>class MGraph:public Graph<T>{public:MGraph(int Vertices=10,T noEdge=0);~MGraph();bool Add(int u,int v,const T& w);bool Delete(int u,int v);bool Exist(int u,int v)const;void Floyd(T**& d,int**& path);void print(int Vertices);private:T NoEdge;T** a;};template<class T>MGraph<T>::MGraph(int V ertices,T noEdge){n=V ertices;NoEdge=noEdge;a=new T* [n];for(int i=0;i<n;i++){a[i]=new T[n];a[i][i]=0;for(int j=0;j<n;j++)if(i!=j)a[i][j]=NoEdge;}}template<class T>MGraph<T>::~MGraph(){for(int i=0;i<n;i++)delete[]a[i];delete[]a;}template<class T>bool MGraph<T>::Exist(int u,int v)const{if(u<0||v<0||u>n-1||v>n-1||u==v||a[u][v]==NoEdge)return false; return true;}template<class T>bool MGraph<T>::Add(int u,int v,const T& w){if(u<0||v<0||u>n-1||v>n-1||u==v||a[u][v]!=NoEdge){cerr<<"BadInput!"<<endl;return false;}a[u][v]=w;e++;return true;}template<class T>bool MGraph<T>:delete(int u,int v){if(u<0||v<0||u>n-1||v>n-1||u==v||a[u][v]==NoEdge){ cerr<<"BadInput!"<<endl;return false;}a[u][v]=NoEdge;e--;return true;}template<class T>void MGraph<T>::Floyd(T**& d,int**& path) {d=new T* [n];path=new int* [n];for(int i=0;i<n;i++){d[i]=new T[n];path[i]=new int[n];for(int j=0;j<n;j++){d[i][j]=a[i][j];if(i!=j&&a[i][j]<NoEdge)path[i][j]=i;else path[i][j]=-1;}}for(int k=0;k<n;k++){for(i=0;i<n;i++)for(int j=0;j<n;j++)if(d[i][k]+d[k][j]<d[i][j]){d[i][j]=d[i][k]+d[k][j];path[i][j]=path[k][j];}}}template<class T>void MGraph<T>::print(int Vertices){for(int i=0;i<Vertices;i++)for(int j=0;j<Vertices;j++){cout<<a[i][j]<<' ';if(j==Vertices-1)cout<<endl;}}#define noEdge 10000#include<iostream.h>void main(){cout<<"请输入该图的节点数："<<endl;int vertices;cin>>vertices;MGraph<float> b(vertices,noEdge);cout<<"请输入u,v,w:"<<endl;int u,v;float w;cin>>u>>v>>w;while(w!=noEdge){//u=u-1;b.Add(u-1,v-1,w);b.Add(v-1,u-1,w);cout<<"请输入u,v,w:"<<endl;cin>>u>>v>>w;}b.print(vertices);int** Path;int**& path=Path;float** D;float**& d=D;b.Floyd(d,path);for(int i=0;i<vertices;i++){for(int j=0;j<vertices;j++){cout<<Path[i][j]<<' ';if(j==vertices-1)cout<<endl;}}int *V;V=new int[vertices+1];cout<<"请输入任意一个初始H-圈："<<endl;for(int n=0;n<=vertices;n++){cin>>V[n];}for(n=0;n<55;n++){for(i=0;i<n-1;i++){for(int j=0;j<n-1;j++){if(i+1>0&&j>i+1&&j<n-1){if(D[V[i]][V[j]]+D[V[i+1]][V[j+1]]<D[V[i]][V[i+1]]+D[V[j]][V[j+1]]){ int l;l=V[i+1];V[i+1]=V[j];V[j]=l;}}}}}float total=0;cout<<"最小回路："<<endl;for(i=0;i<=vertices;i++){cout<<V[i]+1<<' ';}cout<<endl;for(i=0;i<vertices;i++)total+=D[V[i]][V[i+1]];cout<<"最短路径长度："<<endl;cout<<total;}C语言程序：#include<stdio.h>#include<stdlib.h>#include<math.h>#include<alloc.h>#include<conio.h>#include<float.h>#include<time.h>#include<graphics.h>#include<bios.h>#define maxpop 100#define maxstring 100struct pp{unsigned char chrom[maxstring];float x,fitness;unsigned int parent1,parent2,xsite;};struct pp *oldpop,*newpop,*p1;unsigned int popsize,lchrom,gem,maxgen,co_min,jrand;unsigned int nmutation,ncross,jcross,maxpp,minpp,maxxy;float pcross,pmutation,sumfitness,avg,max,min,seed,maxold,oldrand[maxstring]; unsigned char x[maxstring],y[maxstring];float *dd,ff,maxdd,refpd,fm[201];FILE *fp,*fp1;float objfunc(float);void statistics();int select();int flip(float);int crossover();void generation();void initialize();void report();float decode();void crtinit();void inversion();float random1();void randomize1();main(){unsigned int gen,k,j,tt;char fname[10];float ttt;clrscr();co_min=0;if((oldpop=(struct pp *)farmalloc(maxpop*sizeof(struct pp)))==NULL) {printf("memory requst fail!\n");exit(0);}if((dd=(float *)farmalloc(maxstring*maxstring*sizeof(float)))==NULL) {printf("memory requst fail!\n");exit(0);}if((newpop=(struct pp *)farmalloc(maxpop*sizeof(struct pp)))==NULL) {printf("memory requst fail!\n");exit(0);}if((p1=(struct pp *)farmalloc(sizeof(struct pp)))==NULL){printf("memory requst fail!\n");exit(0);}for(k=0;k<maxpop;k++) oldpop[k].chrom[0]='\0';for(k=0;k<maxpop;k++) newpop[k].chrom[0]='\0';printf("Enter Result Data Filename:");gets(fname);if((fp=fopen(fname,"w+"))==NULL){printf("cannot open file\n");exit(0);}gen=0;randomize();initialize();fputs("this is result of the TSP problem:",fp);fprintf(fp,"city: %2d psize: %3d Ref.TSP_path: %f\n",lchrom,popsize,refpd); fprintf(fp,"Pc: %f Pm: %f Seed: %f\n",pcross,pmutation,seed);fprintf(fp,"X site:\n");for(k=0;k<lchrom;k++){if((k%16)==0) fprintf(fp,"\n");fprintf(fp,"%5d",x[k]);}fprintf(fp,"\n Y site:\n");for(k=0;k<lchrom;k++){if((k%16)==0) fprintf(fp,"\n");fprintf(fp,"%5d",y[k]);}fprintf(fp,"\n");crtinit();statistics(oldpop);report(gen,oldpop);getch();maxold=min;fm[0]=100.0*oldpop[maxpp].x/ff;do {gen=gen+1;generation();statistics(oldpop);if(max>maxold){maxold=max;co_min=0;}fm[gen%200]=100.0*oldpop[maxpp].x/ff;report(gen,oldpop);gotoxy(30,25);ttt=clock()/18.2;tt=ttt/60;printf("Run Clock: %2d: %2d: %4.2f",tt/60,tt%60,ttt-tt*60.0); printf("Min=%6.4f Nm:%d\n",min,co_min);}while((gen<100)&&!bioskey(1));printf("\n gen= %d",gen);do{gen=gen+1;generation();statistics(oldpop);if(max>maxold){maxold=max;co_min=0;}fm[gen%200]=100.0*oldpop[maxpp].x/ff;report(gen,oldpop);if((gen%100)==0)report(gen,oldpop);gotoxy(30,25);ttt=clock()/18.2;tt=ttt/60;printf("Run Clock: %2d: %2d: %4.2f",tt/60,tt%60,ttt-tt*60.0); printf("Min=%6.4f Nm:%d\n",min,co_min);}while((gen<maxgen)&&!bioskey(1));getch();for(k=0;k<lchrom;k++){if((k%16)==0)fprintf(fp,"\n");fprintf(fp,"%5d",oldpop[maxpp].chrom[k]);}fprintf(fp,"\n");fclose(fp);farfree(dd);farfree(p1);farfree(oldpop);farfree(newpop);restorecrtmode();exit(0);}/*%%%%%%%%%%%%%%%%*/float objfunc(float x1){float y;y=100.0*ff/x1;return y;}/*&&&&&&&&&&&&&&&&&&&*/void statistics(pop)struct pp *pop;{int j;sumfitness=pop[0].fitness;min=pop[0].fitness;max=pop[0].fitness;maxpp=0;minpp=0;for(j=1;j<popsize;j++){sumfitness=sumfitness+pop[j].fitness;if(pop[j].fitness>max){max=pop[j].fitness;maxpp=j;}if(pop[j].fitness<min){min=pop[j].fitness;minpp=j;}}avg=sumfitness/(float)popsize;}/*%%%%%%%%%%%%%%%%%%%%*/void generation(){unsigned int k,j,j1,j2,i1,i2,mate1,mate2;float f1,f2;j=0;do{mate1=select();pp:mate2=select();if(mate1==mate2)goto pp;crossover(oldpop[mate1].chrom,oldpop[mate2].chrom,j); newpop[j].x=(float)decode(newpop[j].chrom);newpop[j].fitness=objfunc(newpop[j].x);newpop[j].parent1=mate1;newpop[j].parent2=mate2;newpop[j].xsite=jcross;newpop[j+1].x=(float)decode(newpop[j+1].chrom); newpop[j+1].fitness=objfunc(newpop[j+1].x);newpop[j+1].parent1=mate1;newpop[j+1].parent2=mate2;newpop[j+1].xsite=jcross;if(newpop[j].fitness>min){for(k=0;k<lchrom;k++)oldpop[minpp].chrom[k]=newpop[j].chrom[k];oldpop[minpp].x=newpop[j].x;oldpop[minpp].fitness=newpop[j].fitness;co_min++;return;}if(newpop[j+1].fitness>min){for(k=0;k<lchrom;k++)oldpop[minpp].chrom[k]=newpop[j+1].chrom[k];oldpop[minpp].x=newpop[j+1].x;oldpop[minpp].fitness=newpop[j+1].fitness;co_min++;return;}j=j+2;}while(j<popsize);}/*%%%%%%%%%%%%%%%%%*/void initdata(){unsigned int ch,j;clrscr();printf("-----------------------\n");printf("A SGA\n");printf("------------------------\n");/*pause();*/clrscr();printf("*******SGA DATA ENTRY AND INITILIZATION *******\n"); printf("\n");printf("input pop size");scanf("%d",&popsize);printf("input chrom length");scanf("%d",&lchrom);printf("input max generations");scanf("%d",&maxgen);printf("input crossover probability");scanf("%f",&pcross);printf("input mutation prob");scanf("%f",&pmutation);randomize1();clrscr();nmutation=0;ncross=0;}/*%%%%%%%%%%%%%%%%%%%%*/void initreport(){int j,k;printf("pop size=%d\n",popsize);printf("chromosome length=%d\n",lchrom);printf("maxgen=%d\n",maxgen);printf("pmutation=%f\n",pmutation);printf("pcross=%f\n",pcross);printf("initial generation statistics\n");printf("ini pop max fitness=%f\n",max);printf("ini pop avr fitness=%f\n",avg);printf("ini pop min fitness=%f\n",min);printf("ini pop sum fit=%f\n",sumfitness);}void initpop(){unsigned char j1;unsigned int k5,i1,i2,j,i,k,j2,j3,j4,p5[maxstring]; float f1,f2;j=0;for(k=0;k<lchrom;k++)oldpop[j].chrom[k]=k;for(k=0;k<lchrom;k++)p5[k]=oldpop[j].chrom[k];randomize();for(;j<popsize;j++){j2=random(lchrom);for(k=0;k<j2+20;k++){j3=random(lchrom);j4=random(lchrom);j1=p5[j3];p5[j3]=p5[j4];p5[j4]=j1;}for(k=0;k<lchrom;k++)oldpop[j].chrom[k]=p5[k];}for(k=0;k<lchrom;k++)for(j=0;j<lchrom;j++)dd[k*lchrom+j]=hypot(x[k]-x[j],y[k]-y[j]);for(j=0;j<popsize;j++){oldpop[j].x=(float)decode(oldpop[j].chrom); oldpop[j].fitness=objfunc(oldpop[j].x); oldpop[j].parent1=0;oldpop[j].parent2=0;oldpop[j].xsite=0;}}/*&&&&&&&&&&&&&&&&&*/void initialize(){int k,j,minx,miny,maxx,maxy;initdata();minx=0;miny=0;maxx=0;maxy=0;for(k=0;k<lchrom;k++){x[k]=rand();if(x[k]>maxx)maxx=x[k];if(x[k]<minx)minx=x[k];y[k]=rand();if(y[k]>maxy)maxy=y[k];if(y[k]<miny)miny=y[k];}if((maxx-minx)>(maxy-miny)){maxxy=maxx-minx;}else {maxxy=maxy-miny;}maxdd=0.0;for(k=0;k<lchrom;k++)for(j=0;j<lchrom;j++){dd[k*lchrom+j]=hypot(x[k]-x[j],y[k]-y[j]);if(maxdd<dd[k*lchrom+j])maxdd=dd[k*lchrom+j]; }refpd=dd[lchrom-1];for(k=0;k<lchrom;k++)refpd=refpd+dd[k*lchrom+k+2];for(j=0;j<lchrom;j++)dd[j*lchrom+j]=4.0*maxdd;ff=(0.765*maxxy*pow(lchrom,0.5));minpp=0;min=dd[lchrom-1];for(j=0;j<lchrom-1;j++){if(dd[lchrom*j+lchrom-1]<min){min=dd[lchrom*j+lchrom-1];minpp=j;}}initpop();statistics(oldpop);initreport();}/*&&&&&&&&&&&&&&&&&&*/void report(int l,struct pp *pop){int k,ix,iy,jx,jy;unsigned int tt;float ttt;cleardevice();gotoxy(1,1);printf("city:%4d para_size:%4d maxgen:%4d ref_tour:%f\n",lchrom,popsize,maxgen,refpd);printf("ncross:%4d Nmutation:%4d Rungen:%4d A VG=%8.4f MIN=%8.4f\n\n" ,ncross,nmutation,l,avg,min);printf("inpath:%6.4f Minpath length:%10.4f Ref_co_tour:%f\n",pop[maxpp].x/maxxy,pop[maxpp].x,ff);printf("Co_minpath:%6.4f Maxfit:%10.8f",100.0*pop[maxpp].x/ff,pop[maxpp].fitness);ttt=clock()/18.2;tt=ttt/60;printf("Run clock:%2d:%2d:%4d.2f\n",tt/60,tt%60,ttt-tt*60.0);setcolor(1%15+1);for(k=0;k<lchrom-1;k++){ix=x[pop[maxpp].chrom[k]];iy=y[pop[maxpp].chrom[k]]+110;jx=x[pop[maxpp].chrom[k+1]];jy=y[pop[maxpp].chrom[k+1]]+110;line(ix,iy,jx,jy);putpixel(ix,iy,RED);}ix=x[pop[maxpp].chrom[0]];iy=y[pop[maxpp].chrom[0]]+110;jx=x[pop[maxpp].chrom[lchrom-1]];jy=y[pop[maxpp].chrom[lchrom-1]]+110;line(ix,iy,jx,jy);putpixel(jx,jy,RED);setcolor(11);outtextxy(ix,iy,"*");setcolor(12);for(k=0;k<1%200;k++){ix=k+280;iy=366-fm[k]/3;jx=ix+1;jy=366-fm[k+1]/3;line(ix,iy,jx,jy);putpixel(ix,iy,RED);}printf("GEN:%3d",l);printf("Minpath:%f Maxfit:%f",pop[maxpp].x,pop[maxpp].fitness);printf("Clock:%2d:%2d:%4.2f\n",tt/60,tt%60,ttt-tt*60.0); }/*###############*/float decode(unsigned char *pp){int j,k,l;float tt;tt=dd[pp[0]*lchrom+pp[lchrom-1]];for(j=0;j<lchrom-1;j++){tt=tt+dd[pp[j]*lchrom+pp[j+1]];}l=0;for(k=0;k<lchrom-1;k++)for(j=k+1;j<lchrom;j++){if(pp[j]==pp[k])l++;}return tt+4*l*maxdd;}/*%%%%%%%%%%%%%%%%%%*/void crtinit(){int driver,mode;struct palettetype p;driver=DETECT;mode=0;initgraph(&driver,&mode,"");cleardevice();}/*$$$$$$$$$$$$$$$$$$$$*/int select(){double rand1,partsum;float r1;int j;partsum=0.0;j=0;rand1=random1()*sumfitness;do{partsum=partsum+oldpop[j].fitness;j=j+1;}while((partsum<rand1)&&(j<popsize));return j-1;}/*$$$$$$$$$$$$$$$*/int crossover(unsigned char *parent1,unsigned char *parent2,int k5) {int k,j,mutate,i1,i2,j5;int j1,j2,j3,s0,s1,s2;unsigned char jj,ts1[maxstring],ts2[maxstring];float f1,f2;s0=0;s1=0;s2=0;if(flip(pcross)){jcross=random(lchrom-1);j5=random(lchrom-1);ncross=ncross+1;if(jcross>j5){k=jcross;jcross=j5;j5=k;}}else jcross=lchrom;if(jcross!=lchrom){s0=1;k=0;for(j=jcross;j<j5;j++){ts1[k]=parent1[j];ts2[k]=parent2[j];k++;}j3=k;for(j=0;j<lchrom;j++){j2=0;while((parent2[j]!=ts1[j2])&&(j2<k)){j2++;}if(j2==k){ts1[j3]=parent2[j];j3++;}}j3=k;for(j=0;j<lchrom;j++){j2=0;while((parent1[j]!=ts2[j2])&&(j2<k)){j2++;}if(j2==k){ts2[j3]=parent1[j];j3++;}}for(j=0;j<lchrom;j++){newpop[k5].chrom[j]=ts1[j];newpop[k5+1].chrom[j]=ts2[j];}}{for(j=0;j<lchrom;j++){newpop[k5].chrom[j]=parent1[j];newpop[k5+1].chrom[j]=parent2[j];}mutate=flip(pmutation);if(mutate){s1=1;nmutation=nmutation+1;for(j3=0;j3<200;j3++){j1=random(lchrom);j=random(lchrom);jj=newpop[k5].chrom[j];newpop[k5].chrom[j]=newpop[k5].chrom[j1];newpop[k5].chrom[j1]=jj;}}mutate=flip(pmutation);if(mutate){s2=1;nmutation=nmutation+1;for(j3=0;j3<100;j3++){j1=random(lchrom);j=random(lchrom);jj=newpop[k5+1].chrom[j];newpop[k5+1].chrom[j]=newpop[k5+1].chrom[j1];newpop[k5+1].chrom[j1]=jj;}}}j2=random(2*lchrom/3);for(j=j2;j<j2+lchrom/3-1;j++)for(k=0;k<lchrom;k++){if(k==j)continue;if(k>j){i2=k;i1=j;}else{i1=k;i2=j;}f1=dd[lchrom*newpop[k5].chrom[i1]+newpop[k5].chrom[i2]]; f1=f1+dd[lchrom*newpop[k5].chrom[(i1+1)%lchrom]+ newpop[k5].chrom[(i2+1)%lchrom]];f2=dd[lchrom*newpop[k5].chrom[i1]+newpop[k5].chrom[(i1+1)%lchrom]];f2=f2+dd[lchrom*newpop[k5].chrom[i2]+newpop[k5].chrom[(i2+1)%lchrom]];if(f1<f2){inversion(i1,i2,newpop[k5].chrom);}j2=random(2*lchrom/3);for(j=j2;j<j2+lchrom/3-1;j++)for(k=0;k<lchrom;k++){if(k==j)continue;if(k>j){i2=k;i1=j;}else{i1=k;i2=j;}f1=dd[lchrom*newpop[k5+1].chrom[i1]+newpop[k5+1].chrom[i2]]; f1=f1+dd[lchrom*newpop[k5+1].chrom[(i1+1)%lchrom]+ newpop[k5+1].chrom[(i2+1)%lchrom]];f2=dd[lchrom*newpop[k5+1].chrom[i1]+newpop[k5+1].chrom[(i1+1)%lchrom]];f2=f2+dd[lchrom*newpop[k5+1].chrom[i2]+newpop[k5+1].chrom[(i2+1)%lchrom]];if(f1<f2){inversion(i1,i2,newpop[k5+1].chrom);}}return 1;}/*$$$$$$$$$$$$$$$*/void inversion(unsigned int k,unsigned int j,unsigned char *ss) {unsigned int l1,i;unsigned char tt;l1=(j-k)/2;for(i=0;i<l1;i++){tt=ss[k+i+1];ss[k+i+1]=ss[j-i];ss[j-i]=tt;}}/*%%%%%%%%%%%%%%%*/void randomize1(){int i;randomize();for(i=0;i<lchrom;i++)oldrand[i]=random(30001)/30000.0;jrand=0;}/*%%%%%%%%%%%*/float random1(){jrand=jrand+1;if(jrand>=lchrom){jrand=0;randomize1();}return oldrand[jrand];}/*%%%%%%%%%%*/int flip(float probability){float ppp;ppp=random(20001)/20000.0;if(ppp<=probability)return 1;return 0;}改进后用来求解VRP问题的Delphi程序：unit uEA;interfaceusesuUtilsEA, uIEA, uITSP, Classes, GaPara, windows, SysUtils, fEA_TSP;typeTIndividual = class(TInterfacedObject, IIndividual)private// The internally stored fitness valuefFitness: TFloat;fWeConstrain: integer;fBackConstrain: integer;fTimeConstrain: integer;procedure SetFitness(const Value: TFloat);function GetFitness: TFloat;function GetWeConstrain: integer;procedure SetWeConstrain(const Value: integer);procedure SetBackConstrain(const Value: integer);function GetBackConstrain: integer;function GetTimeConstrain: integer;procedure SetTimeConstrain(const Value: integer);publicproperty Fitness : TFloat read GetFitness write SetFitness;property WeConstrain :integer read GetWeConstrain write SetWeConstrain; property BackConstrain :integer read GetBackConstrain write SetBackConstrain; property TimeConstrain :integer read GetTimeConstrain write SetTimeConstrain; end;TTSPIndividual = class(TIndividual, ITSPIndividual)private// The route we travelfRouteArray : ArrayInt;fWeConstrain: integer;fBackConstrain: integer;fTimeConstrain: integer;function GetRouteArray(I: Integer): Integer;procedure SetRouteArray(I: Integer; const Value: Integer);procedure SetSteps(const Value: Integer);function GetSteps: Integer;function GetWeConstrain: integer;procedure SetWeConstrain(const Value: integer);procedure SetBackConstrain(const Value: integer);procedure SetTimeConstrain(const Value: integer);function GetBackConstrain: integer;function GetTimeConstrain: integer;public// Constructor, called with initial route sizeconstructor Create(Size : TInt); reintroduce;destructor Destroy; override;property RouteArray[I : Integer] : Integer read GetRouteArray write SetRouteArray; // The number of steps on the routeproperty Steps : Integer read GetSteps write SetSteps;property Fitness : TFloat read GetFitness write SetFitness;property WeConstrain :integer read GetWeConstrain write SetWeConstrain; property BackConstrain :integer read GetWeConstrain write SetBackConstrain; property TimeConstrain :integer read GetTimeConstrain write SetTimeConstrain; end;TTSPCreator = class(TInterfacedObject, ITSPCreator)private// The Control component we are associated withfController: ITSPController;function GetController: ITSPController;procedure SetController(const Value: ITSPController);public// Function to create a random individualfunction CreateIndividual : IIndividual;function CreateFeasibleIndividual: IIndividual;property Controller : ITSPController read GetController write SetController; end;TKillerPercentage = class(TInterfacedObject, IKillerPercentage)privatefPer: TFloat;procedure SetPercentage(const Value: TFloat);function GetPercentage: TFloat;publicfunction Kill(Pop : IPopulation): Integer;// Percentage of population to be killedproperty Percentage: TFloat read GetPercentage write SetPercentage;end;TParentSelectorTournament = class(TInterfacedObject, IParentSelector)publicfunction SelectParent(Population: IPopulation): IIndividual;end;TTSPBreederCrossover = class(TInterfacedObject, IBreeder)publicfunction BreedOffspring(PSelector: IParentSelector; Pop: IPopulation): IIndividual; end;TTSPMutator = class(TInterfacedObject, ITSPMutator)privatefTrans: TFloat;fInv: TFloat;procedure SetInv(const Value: TFloat);procedure SetTrans(const Value: TFloat);function GetInv: TFloat;function GetTrans: TFloat;publicprocedure Mutate(Individual: IIndividual);published// Probability of doing a transpositionproperty Transposition: TFloat read GetTrans write SetTrans;// Probability of doing an inversionproperty Inversion: TFloat read GetInv write SetInv;end;TTSPExaminer = class(TInterfacedObject, ITSPExaminer)private// The Control component we are associated withfController: ITSPController;function GetController: ITSPController;procedure SetController(const Value: ITSPController);public// Returns the fitness of an individual as a real number where 0 => best function GetFitness(Individual : IIndividual) : TFloat;property Controller : ITSPController read GetController write SetController; end;TPopulation = class(TInterfacedObject, IPopulation)private// The populationfPop : TInterfaceList;// Worker for breedingfBreeder: IBreeder;// Worker for killingfKiller: IKiller;// Worker for parent selectionfParentSelector: IParentSelector;// Worker for mutationfMutator: IMutator;// Worker for initial creationfCreator: ICreator;// Worker for fitness calculationfExaminer: IExaminer;// On Change eventFOnChange: TNotifyEvent;procedure Change;// Getters and Settersfunction GetIndividual(I: Integer): IIndividual;function GetCount: Integer;function GetBreeder: IBreeder;function GetCreator: ICreator;function GetExaminer: IExaminer;function GetKiller: IKiller;function GetMutator: IMutator;function GetOnChange: TNotifyEvent;function GetParentSelector: IParentSelector;procedure SetBreeder(const Value: IBreeder);procedure SetCreator(const Value: ICreator);procedure SetExaminer(const Value: IExaminer);procedure SetKiller(const Value: IKiller);procedure SetMutator(const Value: IMutator);procedure SetOnChange(const Value: TNotifyEvent);procedure SetParentSelector(const Value: IParentSelector);// not interfacedprocedure DanQuickSort(SortList: TInterfaceList; L, R: Integer; SCompare: TInterfaceCompare); procedure Sort(Compare: TInterfaceCompare);protected// Comparison function for Sort()function CompareIndividuals(I1, I2: IIndividual): Integer;// Sort the populationprocedure SortPopulation;public// The constructorconstructor Create;// The destructordestructor Destroy; override;// Adds an individual to the populationprocedure Add(New : IIndividual);// Deletes an individual from the populationprocedure Delete(I : Integer);// Runs a single generationprocedure Generation;// Initialise the populationprocedure Initialise(Size : Integer);// Clear ourselves outprocedure Clear;// Get the fitness of an individualfunction FitnessOf(I : Integer) : TFloat;// Access to the population membersproperty Pop[I : Integer] : IIndividual read GetIndividual; default;// The size of the populationproperty Count : Integer read GetCount;property ParentSelector : IParentSelector read GetParentSelector write SetParentSelector; property Breeder : IBreeder read GetBreeder write SetBreeder;property Killer : IKiller read GetKiller write SetKiller;property Mutator : IMutator read GetMutator write SetMutator;property Creator : ICreator read GetCreator write SetCreator;property Examiner : IExaminer read GetExaminer write SetExaminer;// An eventproperty OnChange : TNotifyEvent read GetOnChange write SetOnChange;end;TTSPController = class(TInterfacedObject, ITSPController) privatefXmin, fXmax, fYmin, fYmax: TFloat;{ The array of 'cities' }fCities : array of TPoint2D;{ The array of 'vehicles' }fVehicles : array of TVehicle;{ The array of 'vehicle number' }fNoVehicles : ArrayInt;/////////////////////{ The number of 'new cities' }fCityCount: Integer;{ The number of 'old cities' }foldCityCount: Integer;{ The number of 'travelers' }fTravelCount:Integer; ///////////////////////{ The number of 'depots' }fDepotCount:Integer; ///////////////////////{ Getters... }function GetCity(I: Integer): TPoint2D;function GetNoVehicle(I: Integer): TInt;function GetCityCount: Integer;function GetOldCityCount: Integer;function GetTravelCount:Integer;function GetDepotCount:Integer;function GetXmax: TFloat;function GetXmin: TFloat;function GetYmax: TFloat;function GetYmin: TFloat;{ Setters... }procedure SetCityCount(const Value: Integer);procedure SetOldCityCount(const Value: Integer); procedure SetTravelCount(const Value: Integer); ///////////// procedure SetDepotCount(const Value: Integer); ///////////// procedure SetXmax(const V alue: TFloat);procedure SetXmin(const Value: TFloat);procedure SetYmax(const V alue: TFloat);procedure SetYmin(const Value: TFloat);function TimeCostBetween(C1, C2: Integer): TFloat; function GetTimeConstraint(Individual: IIndividual): TInt; function DateSpanToMin(d1, d2: TDateTime): integer; function GetVehicleInfo(routeInt: Tint): integer; procedure writeTimeArray;procedure writeCostArray;public。

基于遗传算法的多目标优化与问题求解

基于遗传算法的多目标优化与问题求解遗传算法作为一种生物学启发方式的优化算法，已经在多个领域取得了很好的应用成果。

随着科技的发展，多目标问题也随之增多，遗传算法也逐渐被应用于多目标优化与问题求解领域。

一、遗传算法简介遗传算法是模拟生物进化这一自然现象的一种优化算法，它是通过模仿自然选择的过程进行局部优化，通过遗传操作进行全局优化，从而实现对问题求解的优化。

遗传算法包括遗传编码、选择、交叉和变异等基本操作。

二、多目标优化问题多目标优化问题是指在一个问题中存在多个冲突目标，同时优化多个目标的问题。

例如，在一个工程设计问题中，既要考虑成本，又要考虑时间和质量。

常见的解决方法有权重法和Pareto前沿法。

权重法是将多个目标指标赋上不同的权重，从而将多个目标问题转化为单个目标问题。

然而，这种方法存在两个问题：首先，权重的选取是主观的，对问题的求解结果有很大的影响；其次，在目标之间存在冲突时，无法确定最优的权重。

Pareto前沿法是一种解决多目标问题的重要方法。

它利用了帕累托（Pareto）最优解的概念，将多个目标之间的关系转化为一个求解帕累托最优解的问题，从而达到同时考虑多个目标的目的。

三、遗传算法与多目标优化问题的结合遗传算法被广泛运用于多目标优化问题的求解。

在遗传算法中，常用的求解多目标问题的方法有多目标遗传算法和NSGA-II（非支配排序遗传算法）。

多目标遗传算法的主要思想是将多个目标优化问题转化为一组顺序问题，并将问题中的各个目标的优化过程联合起来，同时考虑各个目标的极点，从而达到寻找全局最优解的目的。

多目标遗传算法有许多变种，比如Pareto遗传算法，Vega遗传算法等。

NSGA-II是一种改进型的非支配排序遗传算法，它不仅可以有效地解决多目标优化问题，而且其求解效率和求解效果都比较好。

NSGA-II的主要特点是利用帕累托最优解的概念来解决多目标优化问题，同时采用非支配排序、拥挤度距离等策略来进行多目标问题的优化。

用遗传算法求解旅行商问题时遗传算子的设计

旅行商问题（ｒｅｎａｓａｒｌＴＰ，ＴａｌｇｌｍｎｏｅＳ）也称为货郎担问题，ｖｉＳｅＰｂｍ，给定一组ｎ个城市和它们两两之间的直
达距离，寻找一条闭合的路程，使得每个城市刚好经过一次且总的旅行距离最短．随着城市数目的增加，ＳＴＰ的搜
２１交叉．
２１１部分匹配交叉算子．．
在两个父代个体中随机选取两个交叉点，确定一个匹配段，根据选定的匹配段定义一系列映射关系．首先，交换两个父个体的匹配段，然后对匹配段之外的其他基因位，使用最初的父码，按照映射关系经过交换得到相应位
上的码值．
索空问迅速扩大，已被证明属于ＮＰ完全问题，利用传统方法求解这一问题非常困难，本文重点介绍利用遗传算
法解ＴＰ问题的两个重要算子，Ｓ即交叉和变异算子．
１遗传算法简介
遗传算法是２世纪８ＯＯ年代中期蓬勃发展起来的一种模仿生物进化过程的随机方法，它借鉴了自然界“ 物竟
生新的个体，就像人类的婚配过程，通过交叉重组操作，遗传算法的搜索能力大大提高，因重组和交叉是遗传算基
法获取新优良个体的最重要手段．
３变异算子：．类似于人类的基因突变，保持了种群的多样性，与选择／重组算子结合在一起，保证了遗传算法
的有效性，以防止出现非成熟收敛．
接的表示方式就是按照旅程经过的次序进行编码，每一种旅行方式就是一个个体．但是ＴＰ问题要求一个城市必Ｓ
须而且只能访问一次，也就是说每一个个体的染色体中不允许出现重复的基因码，这样，经过基本遗传算法的交叉和变异操作就会产生无意义的个体．下面介绍处理ＴＰ问题的遗传操作：Ｓ

(精品)遗传算法求解背包问题

遗传算法的过程：初始化：将计划装入背包的每个物品看成一个二进制串的一位，为1表示放入该物品，为0表示不放入该物品。

初始种群的产生：初始化前对放入背包物品数的一个预测（背包容积/物品最大体积），接下来只要在种群每条染色体中保证有（背包容积/物品最大体积）个为1的位初始化就完成了。

选择：选择进行杂交的父代染色体，被选中的父代染色体总是若干个染色体中最优（适应度最高）的，来保证向优化的方向发展。

详细的选择方法：随机产生2个数：Chrom_Cross_From, Chrom_Cross_To,当然得采用一定的手段来保证前者比后者小。

从Chrom_Cross_From到Chrom_Cross_To这Chrom_Cross_To-Chrom_Cross_From+1条染色体中选择最优（适应度最大）的染色体作为父代之一。

需要进行两次选择得到杂交的两条父代染色体。

这样做可以保证算法不会过早收敛。

函数实现：Individual Select(int ChromSize,Individual Pop[]){int Num_Selected,i,j,Chrom_Selected_From,Chrom_Selected_To,temp;Individual *Chrom_Selected;do{Chrom_Selected_From=rand()%PopSize;Chrom_Selected_To=rand()%PopSize;if(Chrom_Selected_From>Chrom_Selected_To){temp=Chrom_Selected_From;Chrom_Selected_From=Chrom_Selected_To;Chrom_Selected_To=temp;}Num_Selected=Chrom_Selected_To-Chrom_Selected_From+1;}while(Num_Selected<=0);Chrom_Selected=new Individual[Num_Selected];for(i=0;i<Num_Selected;i++)Chrom_Selected[i].chrom=new int[ChromSize];for(i=0,j=Chrom_Selected_From;i<Num_Selected,j<Chrom_Selected_To+1;i++,j++){Chrom_Selected[i]=Pop[j];}Order_Best_First(ChromSize,Num_Selected,Chrom_Selected);Chrom_Selected[0].fitness=Fitness(Chrom_Selected[0].chrom,ChromSize);return Chrom_Selected[0];}杂交：将两次选择得到的父代染色体进行杂交得到一条新的染色体，作为较新种群（并非新的种群）的一条染色体，杂交直到较新种群的染色体数等于原种群的染色体数。

货郎担问题

(3) 将排定位置的工作所对于能够的列从 M中划掉,然后对余下的工作重复按(2)进行, 但那时的最前位置(或最后位置)是在已排定位置的工件之后(或之前).如此继续下去,直至把所有工件都排完为止.
解:工件的加工工时矩阵为
根据最优排序规则,最优加工顺序为: 13542
这是Johnson在1954年提出的解法.概括起来,这种解法的基本思路是:尽量减少在机床B上等待加工的时间.(A上加工的时间不受限制)因此,把在机床B上加工时间长的工件先加工,在B上加工时间短的工件后加工. 我们上学期学的数据结构里面也有很多内容和货郎担问题的思想是相似!
当k=2时,从城市V1出发,中间经过2个城镇到达Vi的最短距离. f2(2,{ 3,4 }) = min[ f1(3,{4})+d 32,f1(4,{3})+ d42 ] =min[14+8,15+5]=20 P2(2,{3,4})=4
f2(3,{ 2,4 })= min[14+9,13+5]=18 P2(3,{2,4})=4 f2(4,{ 2,3 })= min[15+7,15+8]=22 P2(4,{2,3})=2
当k=3时: 从城市V1出发,中间经过3个城镇最终回到Vi的最短距离. f3(1,{ 2,3, 4 })= min[f2(2,{ 3,4 }) + d 21,f2(3,{ 2,4 })+ d 31, f2(4,{ 2,3 }) + d 41 ]=min[20+8,18+5,22+6]=23 P3(1,{2,3,4})=3
这是因为：1，各城市之间可能是复线2，两地之间可能会使用不同的交通工具从而费用不同。

遗传算法（GeneticAlgorithms）

遗传算法（GeneticAlgorithms）遗传算法前引：1、TSP问题1.1 TSP问题定义旅⾏商问题（Traveling Salesman Problem，TSP）称之为货担郎问题，TSP问题是⼀个经典组合优化的NP完全问题，组合优化问题是对存在组合排序或者搭配优化问题的⼀个概括，也是现实诸多领域相似问题的简化形式。

1.2 TSP问题解法传统精确算法：穷举法，动态规划近似处理算法：贪⼼算法，改良圈算法，双⽣成树算法智能算法：模拟退⽕，粒⼦群算法，蚁群算法，遗传算法等遗传算法：性质：全局优化的⾃适应概率算法2.1 遗传算法简介遗传算法的实质是通过群体搜索技术，根据适者⽣存的原则逐代进化，最终得到最优解或准最优解。

它必须做以下操作：初始群体的产⽣、求每⼀个体的适应度、根据适者⽣存的原则选择优良个体、被选出的优良个体两两配对，通过随机交叉其染⾊体的基因并随机变异某些染⾊体的基因⽣成下⼀代群体，按此⽅法使群体逐代进化，直到满⾜进化终⽌条件。

2.2 实现⽅法根据具体问题确定可⾏解域，确定⼀种编码⽅法，能⽤数值串或字符串表⽰可⾏解域的每⼀解。

对每⼀解应有⼀个度量好坏的依据，它⽤⼀函数表⽰，叫做适应度函数，⼀般由⽬标函数构成。

确定进化参数群体规模、交叉概率、变异概率、进化终⽌条件。

案例实操我⽅有⼀个基地，经度和纬度为（70，40）。

假设我⽅飞机的速度为1000km/h。

我⽅派⼀架飞机从基地出发，侦察完所有⽬标，再返回原来的基地。

在每⼀⽬标点的侦察时间不计，求该架飞机所花费的时间（假设我⽅飞机巡航时间可以充分长）。

已知100个⽬标的经度、纬度如下表所列:3.2 模型及算法求解的遗传算法的参数设定如下：种群⼤⼩M=50；最⼤代数G=100;交叉率pc=1，交叉概率为1能保证种群的充分进化；变异概率pm=0.1，⼀般⽽⾔，变异发⽣的可能性较⼩。

编码策略:初始种群：⽬标函数：交叉操作：变异操作：选择：算法图：代码实现：clc,clear, close allsj0=load('data12_1.txt');x=sj0(:,1:2:8); x=x(:);y=sj0(:,2:2:8); y=y(:);sj=[x y]; d1=[70,40];xy=[d1;sj;d1]; sj=xy*pi/180; %单位化成弧度d=zeros(102); %距离矩阵d的初始值for i=1:101for j=i+1:102d(i,j)=6370*acos(cos(sj(i,1)-sj(j,1))*cos(sj(i,2))*...cos(sj(j,2))+sin(sj(i,2))*sin(sj(j,2)));endendd=d+d'; w=50; g=100; %w为种群的个数，g为进化的代数for k=1:w %通过改良圈算法选取初始种群c=randperm(100); %产⽣1，...，100的⼀个全排列c1=[1,c+1,102]; %⽣成初始解for t=1:102 %该层循环是修改圈flag=0; %修改圈退出标志for m=1:100for n=m+2:101if d(c1(m),c1(n))+d(c1(m+1),c1(n+1))<...d(c1(m),c1(m+1))+d(c1(n),c1(n+1))c1(m+1:n)=c1(n:-1:m+1); flag=1; %修改圈endendendif flag==0J(k,c1)=1:102; break %记录下较好的解并退出当前层循环endendendJ(:,1)=0; J=J/102; %把整数序列转换成[0,1]区间上实数即染⾊体编码for k=1:g %该层循环进⾏遗传算法的操作for k=1:g %该层循环进⾏遗传算法的操作A=J; %交配产⽣⼦代A的初始染⾊体c=randperm(w); %产⽣下⾯交叉操作的染⾊体对for i=1:2:wF=2+floor(100*rand(1)); %产⽣交叉操作的地址temp=A(c(i),[F:102]); %中间变量的保存值A(c(i),[F:102])=A(c(i+1),[F:102]); %交叉操作A(c(i+1),F:102)=temp;endby=[]; %为了防⽌下⾯产⽣空地址，这⾥先初始化while ~length(by)by=find(rand(1,w)<0.1); %产⽣变异操作的地址endB=A(by,:); %产⽣变异操作的初始染⾊体for j=1:length(by)bw=sort(2+floor(100*rand(1,3))); %产⽣变异操作的3个地址%交换位置B(j,:)=B(j,[1:bw(1)-1,bw(2)+1:bw(3),bw(1):bw(2),bw(3)+1:102]);endG=[J;A;B]; %⽗代和⼦代种群合在⼀起[SG,ind1]=sort(G,2); %把染⾊体翻译成1，...,102的序列ind1num=size(G,1); long=zeros(1,num); %路径长度的初始值for j=1:numfor i=1:101long(j)=long(j)+d(ind1(j,i),ind1(j,i+1)); %计算每条路径长度endend[slong,ind2]=sort(long); %对路径长度按照从⼩到⼤排序J=G(ind2(1:w),:); %精选前w个较短的路径对应的染⾊体endpath=ind1(ind2(1),:), flong=slong(1) %解的路径及路径长度xx=xy(path,1);yy=xy(path,2);plot(xx,yy,'-o') %画出路径以上整个代码中没有调⽤GA⼯具箱。

“遗传算法”解决“背包问题”

“遗传算法”解决“背包问题”遗传算法基本思想：1) ⼀个种群有多个个体，每个个体有染⾊体和对应的基因为了繁殖进⾏：2) 选择：在残酷的世界中，适者⽣存，优胜略汰。

3) 重组：染⾊体交叉，基因重组4) 突变：染⾊体上的基因⼩概率的突变（⼀般给⼩数点后两位）背包问题：背包只能容得下⼀定重量b的物品，物品有m种，每种物品有⾃⼰的重量w(i)和价值v(i)（0<i<=m），从这些物品中选择装⼊背包，是背包不超过重量b，但价值⼜要最⼤。

运⽤动态规划，分⽀限界都可以达到效果，但不佳。

我⽤遗传算法解决：⼀般⼈有多条染⾊体，但对于背包问题，⼀个解我们将看成⼀个个体，所以，⼀个个体只有⼀个染⾊体，⼀个染⾊体对应多个基因。

如：100101010100111 表⽰装⼊背包的可能解。

（具体情况具体分析）遗传所做准备：1) ⽤0表⽰“不选择装⼊”，1表⽰“装⼊”，形成⼀条基因链；100101010100111则表⽰“15种物品”装⼊或不装⼊背包的可能解。

------- 此处⽤chrom[]存放基因，代表染⾊体2) ⼀个基因对应⼀个个体。

------- 此处⽤Population类或结构体声明其含有chrom[]等信息3) 可能的解有很多，构成⼀个种群。

------- ⽤Population类定义⼀个数组代表个体构成的种群newPop[]：存放新⽣代，oldPop[]：存放上⼀代4) 适应度：适应度和⽬标函数是正相关的，所以需要物品价值和重量。

------- fitness,weight包含在Population类中最⼤适应度：maxFitness,最⼩适应度：minFitness,总适应度：sumFitness,(帮助求突变和交叉的染⾊体)平均适应度：avgFitness遗传算法的函数：基本：1) InitPop() 初始化个体，使每个个体都有基因组2) Statistics(*pop) 计算适应度（最⼤，最⼩，总的，平均的）3) Selection(*pop) 通过选择种群中符合要求的⽗母去繁殖新代，返回这对⽗母的位置4) crossover(*parent1,*parent2,pos) 传⼊要改的个体位置，随机产⽣交叉位置，⽤优良⽗母繁殖优良后代并替代传⼊个体位置5) mutation(i) i为基因组基因的位置，逐个基因看是否要变异6) generation() 对个体进⾏判断，若不符合要求，进⾏选择，重组，突变。

遗传算法求解TSP问题

遗传算法求解TSP问题1、遗传算法前⼀篇遗传算法的基本内容在之前的博客已经应⽤过了之前遗传算法解决的是函数优化问题，即求解最⼤值或最⼩值问题；此次要解决的是组合优化问题中的TSP问题，即旅⾏商问题。

这边先介绍⼀下TSP问题TSP问题（Traveling Salesman Problem），即旅⾏商问题，⼜译为旅⾏推销员问题、货郎担问题，是数学领域中著名问题之⼀。

假设有⼀个旅⾏商⼈要拜访n个城市，他必须选择所要⾛的路径，路径的限制是每个城市只能拜访⼀次，⽽且最后要回到原来出发的城市。

路径的选择⽬标是要求得的路径路程为所有路径之中的最⼩值。

简单地说，TSP问题就是要找到图中的最短哈密尔顿回路，即全局最短路径。

然后遗传算法可以模仿⽣物进化，然后可以找到⼀个近似最优解，但其不⼀定是全局最优解。

2、实验原理1）产⽣初始种群；随机⽣成N个个体作为初始群体popm，随机选择⼀个种群；2）适应度函数；个体评价计算P（t）中各个个体的适应度，遗传算法在进化搜索中基本不利⽤外部信息,仅以适应度函数为依据,利⽤种群中每个个体的适应度值来进⾏搜索。

TSP的⽬标是路径总长度为最短3）选择运算；将使适应度较⼤(优良)个体有较⼤的存在机会，⽽适应度较⼩（低劣）的个体继续存在的机会也较⼩。

简单遗传算法采⽤赌轮选择机制4）交叉运算将交叉算⼦作⽤于群体；5）变异运算将变异算⼦作⽤于群体，并通过以上运算得到下⼀代群体P（t + 1）;6）终⽌条件输出解。

3、代码实现1.city.m：随机⽣成N个城市的坐标并保存2.plot_route.m：实现连点画图3.染⾊体的路程代价函数 mylength.m4.适应度函数fit.m5.交叉操作函数 cross.m6.变异函数 Mutation.m7.main函数3、结果分析调整参数并分析运⾏结果（1）对于city_25.mat⽂件中的城市序列，参数ITER=2000，m=2，Pc=0.8，Pm=0.05保持不变，调整种群个数M的值，观察其结果变化：M=50M=100M=500由运⾏结果可知当M=100时得到TSP的最短路径长度均⼩于M=50和M=500运⾏得出的最短路径长度。

遗传算法在物流配送车辆优化调度中的应用

遗传算法在物流配送车辆优化调度中的应用遗传算法是一种模拟自然界遗传机制的优化算法，常被用于解决复杂的优化问题，如物流配送车辆的优化调度。

物流配送车辆的优化调度问题是指在满足各种约束条件下，合理安排运输车辆的路径和顺序，以最大程度地提高运输效率、降低成本。

在这个过程中，遗传算法能够用来最优解，从而优化配送车辆调度。

遗传算法通过模仿自然选择、交叉和变异等基本生物学原理，在优化空间中寻找最佳解。

物流配送车辆优化调度问题可以通过遗传算法的基本流程来解决：1.初始化种群：将问题抽象为一组染色体，每个染色体代表一个可能的解（代表车辆的路径和顺序）。

初始种群通过随机生成进行初始化。

2.适应度评估：根据问题的特定条件，计算每个染色体的适应度值，用于评估其质量。

适应度值可以基于目标函数（如最短路径或最小成本）来定义。

3.选择操作：根据适应度值，选择一部分优秀的染色体来产生下一代。

常用的选择操作有轮盘赌选择和竞争选择等。

4.交叉操作：选取两个染色体作为父本，通过交叉操作生成子代。

交叉操作可以通过随机选取交叉点，将两个父本的部分基因进行交换。

5.变异操作：对新生成的子代进行变异操作，增加种群的多样性。

变异操作可以通过随机选择部分基因，并随机改变其值。

6.更新种群：用新生成的子代替代原有的染色体，形成新的种群。

7.重复步骤2至6，直到达到停止条件（如达到最大迭代次数或找到满足要求的解）。

通过迭代优化，遗传算法能够找到最佳的车辆路径和顺序，以实现物流配送的效率最大化和成本最优化。

1.并行处理：遗传算法的基本操作可以并行计算，提高了效率。

2.灵活性：遗传算法可以处理复杂的约束条件，如不同车辆的载重限制、时间窗口约束等。

3.鲁棒性：遗传算法是一种启发式算法，不容易陷入局部最优解，能够在多个起始点进行。

4.可拓展性：遗传算法可以与其他优化算法结合，如模拟退火算法、蚁群算法等，进一步提高效率。

遗传算法在物流配送车辆优化调度中的应用已取得了很好的效果。