遗传算法大作业

⑴ 求一个优化设计解决实际工程问题的案例

比较着名的问题有 背包问题 旅行商问题等，算法有模拟退火、遗传算法等。
想要真实的实际问题 建议你去中国知网搜一搜 应该有好多

⑵ 遗传算法具体应用

1、函数优化

函数优化是遗传算法的经典应用领域，也是遗传算法进行性能评价的常用算例，许多人构造出了各种各样复杂形式的测试函数：连续函数和离散函数、凸函数和凹函数、低维函数和高维函数、单峰函数和多峰函数等。

2、组合优化

随着问题规模的增大，组合优化问题的搜索空间也急剧增大，有时在目前的计算上用枚举法很难求出最优解。对这类复杂的问题，人们已经意识到应把主要精力放在寻求满意解上，而遗传算法是寻求这种满意解的最佳工具之一。

此外，GA也在生产调度问题、自动控制、机器人学、图象处理、人工生命、遗传编码和机器学习等方面获得了广泛的运用。

3、车间调度

车间调度问题是一个典型的NP-Hard问题，遗传算法作为一种经典的智能算法广泛用于车间调度中，很多学者都致力于用遗传算法解决车间调度问题，现今也取得了十分丰硕的成果。

从最初的传统车间调度（JSP）问题到柔性作业车间调度问题（FJSP），遗传算法都有优异的表现，在很多算例中都得到了最优或近优解。

(2)遗传算法大作业扩展阅读：

遗传算法的缺点

1、编码不规范及编码存在表示的不准确性。

2、单一的遗传算法编码不能全面地将优化问题的约束表示出来。考虑约束的一个方法就是对不可行解采用阈值，这样，计算的时间必然增加。

3、遗传算法通常的效率比其他传统的优化方法低。

4、遗传算法容易过早收敛。

5、遗传算法对算法的精度、可行度、计算复杂性等方面，还没有有效的定量分析方法。

⑶ 遗传算法二进制编码问题：二进制编码的位数是如何确定的

用这个公式试试，这个是解码用的，至于你说的位数，可以给你举个例子，比如[0,1],精度千分之1，就是相当于里面离散化出来1000+1个点，2的10次方是1024,2的9次方是512，这时候你就只要取10位就可以把这1001个点的变化全部包含到二进制里面了

⑷ 麦夸特算法和遗传算法的结合，会什么情况！

英国容积单位，相当于290.95立方分米；也就是一在瓶威士忌

⑸ 第9章怎样研究算法遗传算法示例练习题答案解析

你要是是认真学习想对对答案，就直接不要答案了，作业没有多大意义；如果为了完成任务，这又是何必了，如果想提高成绩，还是老老实做吧。

⑹ 跪求大师解决一个数学建模问题，选修课作业，题目在问题补充

（1）这就是运输问题，用运筹学的单纯形解，或上网找软件lingo可解
（2）重新设点可使用遗传算法或粒子群算法求解。

⑺ 应用遗传算法求解tsp问题程序有那个高手帮帮我啊谢谢啦

#include <cmath>

#include <ctime>

#include <vector>

#include <map>

#include <string>

#include <iostream>

#include <algorithm>

using namespace std;

float pcross = 0.85; //交叉率

float pmutation = 0.1; //变异率

int popsize = 300; //种群大小

const int lchrom = 20; //染色体长度

int gen; //当前世代

int maxgen = 100; //最大世代数

int run; //当前运行次数

int maxruns =10; //总运行次数

float max_var = 9 ; //路径最大连接开销!!

//基因定义(一个城市)

struct Gene

{

string name;

map<Gene*,float> linkCost; //该城市到其它城市的路程开销

};

//染色体定义(到各城市顺序的一种组合)

struct Chrom

{

vector<Gene*> chrom_gene; //染色体（到各城市去的顺序）

float varible; //路程总开销

float fitness; //个体适应度

};

//种群定义

struct Pop

{

vector<Chrom> pop_chrom; //种群里的染色体组

float sumfitness; //种群中个体适应度累计

};

Pop oldpop; //当前代种群

Pop newpop; //新一代种群

vector<Gene> genes(lchrom); //保存全部基因

//产生一个随机整数(在low和high之间)

inline int randomInt(int low,int high)

{

if(low==high)

return low;

return low+rand()%(high-low+1);

}

//计算一条染色体的个体适应度

inline void chromCost(Chrom& chr)

{

float sum=0;

for(int i=0;i<chr.chrom_gene.size()-1;i++)

{

sum += (chr.chrom_gene[i])->linkCost[chr.chrom_gene[i+1]];

}

sum += (chr.chrom_gene.front())->linkCost[chr.chrom_gene.back()];

chr.varible=sum;

chr.fitness=max_var*(lchrom) - chr.varible;

}

//计算一个种群的个体适应度之和

inline void popCost(Pop &pop)

{

float sum=0;

for(int i=0;i<pop.pop_chrom.size();i++)

{

sum+=pop.pop_chrom[i].fitness;

}

pop.sumfitness = sum;

}

void outChrom(Chrom& chr);

//随机初始化一条染色体

inline void initChrom(Chrom& chr)

{

vector<int> tmp(lchrom);

for(int i=0;i<lchrom;i++)

tmp[i]=i;

int choose;

while(tmp.size()>1)

{

choose=randomInt(0,tmp.size()-1);

chr.chrom_gene.push_back(&genes[tmp[choose]]);

tmp.erase(tmp.begin()+choose);

}

chr.chrom_gene.push_back(&genes[tmp[0]]);

chromCost(chr);

}

//随机初始化种群

inline void initpop(Pop& pop)

{

pop.pop_chrom.reserve(popsize);

Chrom tmp;

tmp.chrom_gene.reserve(lchrom);

for(int i=0;i<popsize;i++)

{

initChrom(tmp);

pop.pop_chrom.push_back(tmp);

tmp.chrom_gene.clear();

}

popCost(pop);

}

//轮盘赌选择,返回种群中被选择的个体编号

inline int selectChrom(const Pop& pop)

{

float sum = 0;

float pick = float(randomInt(0,1000))/1000;

int i = 0;

if(pop.sumfitness!=0)

{

while(1)

{

sum += pop.pop_chrom[i].fitness/pop.sumfitness;

i++;

if( (sum > pick) || i==pop.pop_chrom.size()-1)

return i-1; }

}

else

return randomInt(0,pop.pop_chrom.size()-2);

}

//精英策略，返回最优秀的一条染色体

inline int chooseBest(const Pop& pop)

{ int choose = 0;

float best = 0;

for(int i = 0;i< pop.pop_chrom.size();i++)

{ if(pop.pop_chrom[i].fitness > best)

{ best = pop.pop_chrom[i].fitness;

choose = i;}

}

return choose；}

//染色体交叉操作,由两个父代产生两个子代(顺序交叉OX)

inline void crossover(Chrom& parent1,Chrom& parent2,Chrom& child1,Chrom& child2)

{ child1.chrom_gene.resize(lchrom);

child2.chrom_gene.resize(lchrom);

vector<Gene*>::iterator v_iter,p1_beg,p2_beg,c1_beg,c2_beg,p1_end,p2_end,c1_end,c2_end;

p1_beg = parent1.chrom_gene.begin();

p2_beg = parent2.chrom_gene.begin();

c1_beg = child1.chrom_gene.begin();

c2_beg = child2.chrom_gene.begin();

p1_end = parent1.chrom_gene.end();

p2_end = parent2.chrom_gene.end();

c1_end = child1.chrom_gene.end();

c2_end = child2.chrom_gene.end();

vector<Gene*> v1(parent2.chrom_gene), v2(parent1.chrom_gene); //用于交叉的临时表

//随机选择两个交叉点

int pick1 = randomInt(1,lchrom-3);

int pick2 = randomInt(pick1+1,lchrom-2);

int dist = lchrom-1-pick2; //第二交叉点到尾部的距离

//子代保持两交叉点间的基因不变

(p1_beg+pick1, p1_beg+pick2+1, c1_beg+pick1);

(p2_beg+pick1, p2_beg+pick2+1, c2_beg+pick1);

//循环移动表中元素

rotate(v1.begin(), v1.begin()+pick2+1,v1.end());

rotate(v2.begin(), v2.begin()+pick2+1,v2.end());

//从表中除去父代已有的元素

for(v_iter = p1_beg+pick1; v_iter!=p1_beg+pick2+1; ++v_iter)

remove(v1.begin(),v1.end(),*v_iter);

for(v_iter = p2_beg+pick1; v_iter!=p2_beg+pick2+1; ++v_iter)

remove(v2.begin(),v2.end(),*v_iter);

//把表中元素复制到子代中

(v1.begin(), v1.begin()+dist, c1_beg+pick2+1);

(v1.begin()+dist, v1.begin()+dist+pick1, c1_beg);

(v2.begin(), v2.begin()+dist, c2_beg+pick2+1);

(v2.begin()+dist, v2.begin()+dist+pick1, c2_beg);

}

//染色体变异操作,随机交换两个基因

inline void mutation(Chrom& chr)

{

vector<Gene*>::iterator beg = chr.chrom_gene.begin();

int pick1,pick2;

pick1 = randomInt(0,lchrom-1);

do{

pick2 =randomInt(0,lchrom-1);

}while(pick1==pick2);

iter_swap(beg+pick1, beg+pick2);

}

//世代进化(由当前种群产生新种群)

void generation(Pop& oldpop,Pop& newpop)

{ newpop.pop_chrom.resize(popsize);

int mate1,mate2,j;

float pick;

float tmp;

Chrom gene1,gene2,tmp1,tmp2;

gene1.chrom_gene.resize(lchrom);

gene2.chrom_gene.resize(lchrom);

tmp1.chrom_gene.resize(lchrom);

tmp2.chrom_gene.resize(lchrom);

//将最佳染色体放入下一代

mate1 = chooseBest(oldpop);

newpop.pop_chrom[0] = oldpop.pop_chrom[mate1];

j = 1;

//产生两条新染色体

do{

int count = 0;

mate1 = selectChrom(oldpop);

mate2 = selectChrom(oldpop);

pick = float(randomInt(0,1000))/1000;

gene1= oldpop.pop_chrom[mate1];

gene2= oldpop.pop_chrom[mate1];

if(pick < pcross) //交叉操作

{

int count = 0;

bool flag1 = false;

bool flag2 = false;

while(1)

{

crossover(oldpop.pop_chrom[mate1],oldpop.pop_chrom[mate2],tmp1,tmp2);

chromCost(tmp1); //计算适应度

chromCost(tmp2);

if(tmp1.fitness > gene1.fitness)

{

gene1 = tmp1;

flag1 = true;}

if(tmp2.fitness > gene2.fitness)

{

gene2 = tmp2;

flag2 = true;

}

if((flag1==true && flag2==true) || count> 50)

{

newpop.pop_chrom[j] = gene1;

newpop.pop_chrom[j+1] = gene2;

break;

}

count++;

}

}

else

{

newpop.pop_chrom[j].chrom_gene = oldpop.pop_chrom[mate1].chrom_gene;

newpop.pop_chrom[j+1].chrom_gene = oldpop.pop_chrom[mate2].chrom_gene;

chromCost(newpop.pop_chrom[j]);

chromCost(newpop.pop_chrom[j+1]);

}

pick = float(randomInt(0,1000))/1000;

if(pick < pmutation) //变异操作

{

int count = 0;

do{

tmp = newpop.pop_chrom[j].fitness;

mutation(newpop.pop_chrom[j]);

chromCost(newpop.pop_chrom[j]); //计算适应度

count++;

}while(tmp > newpop.pop_chrom[j].fitness && count < 50);

}

pick = float(randomInt(0,1000))/1000;

if(pick < pmutation) //变异操作

{

int count = 0;

do{

tmp = newpop.pop_chrom[j+1].fitness;

mutation(newpop.pop_chrom[j+1]);

chromCost(newpop.pop_chrom[j+1]); //计算适应度

count++;

}while(tmp > newpop.pop_chrom[j+1].fitness && count < 50);

}

//chromCost(newpop.pop_chrom[j]); //计算适应度

//chromCost(newpop.pop_chrom[j+1]);

j += 2;

}while(j < popsize-1);

popCost(newpop); //计算新种群的适应度之和

}

//输出一条染色体信息

inline void outChrom(Chrom& chr)

{

cout<<endl<<"路径:";

for(int i=0;i<lchrom;i++)

{

cout<<chr.chrom_gene[i]->name;

}

cout<<endl<<"回路总开销:"<<chr.varible<<endl;

cout<<"适应度:"<<chr.fitness<<endl;

}

int main()

{

cout<<"*************用遗传算法解决TSP(旅行商)问题******************"<<endl;

string names[lchrom]={"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T"};//基因（城市）名称

//用矩阵保存各城市间的路程开销

float dist[lchrom][lchrom] ={{0, 1, 4, 6, 8, 1, 3, 7, 2, 9, 7, 3, 4, 5, 8, 9, 2, 8, 2, 8},{1, 0, 7, 5, 3, 8, 3, 4, 2, 4, 4, 6, 2, 8, 2, 9, 4, 5, 2, 1},{4, 7, 0, 3, 8, 3, 7, 9, 1, 2, 5, 8, 1, 8, 9, 4, 7, 4, 8, 4},{6, 5, 3, 0, 3, 1, 5, 2, 9, 1, 3, 5, 7, 3, 4, 7, 3, 4, 5, 2},

{8, 3, 8, 3, 0, 2, 3, 1, 4, 6, 3, 8, 4, 5, 2, 8, 1, 7, 4, 7},{1, 8, 3, 1, 2, 0, 3, 3, 9, 5, 4, 5, 2, 7, 3, 6, 2, 3, 7, 1},{3, 3, 7, 5, 3, 3, 0, 7, 5, 9, 3, 4, 5, 9, 3, 7, 3, 2, 8, 1},{7, 4, 9, 2, 1, 3, 7, 0, 1, 3, 4, 5, 2, 7, 6, 3, 3, 8, 3, 5},

{2, 2, 1, 9, 4, 9, 5, 1, 0, 1, 3, 4, 7, 3, 7, 5, 9, 2, 1, 7},{9, 4, 2, 1, 6, 5, 9, 3, 1, 0, 3, 7, 3, 7, 4, 9, 3, 5, 2, 5},{7, 4, 5, 3, 3, 4, 3, 4, 3, 3, 0, 5, 7, 8, 4, 3, 1, 5, 9, 3},{3, 6, 8, 5, 8, 5, 4, 5, 4, 7, 5, 0, 8, 3, 1, 5, 8, 5, 8, 3},

{4, 2, 1, 7, 4, 2, 5, 2, 7, 3, 7, 8, 0, 5, 7, 4, 8, 3, 5, 3},{5, 8, 8, 3, 5, 7, 9, 7, 3, 7, 8, 3, 5, 0, 8, 3, 1, 8, 4, 5},{8, 2, 9, 4, 2, 3, 3, 6, 7, 4, 4, 1, 7, 8, 0, 4, 2, 1, 8, 4},{9, 9, 4, 7, 8, 6, 7, 3, 5, 9, 3, 5, 4, 3, 4, 0, 4, 1, 8, 4},

{2, 4, 7, 3, 1, 2, 3, 3, 9, 3, 1, 8, 8, 1, 2, 4, 0, 4, 3, 7},{8, 5, 4, 4, 7, 3, 2, 8, 2, 5, 5, 5, 3, 8, 1, 1, 4, 0, 2, 6},{2, 2, 8, 5, 4, 7, 8, 3, 1, 2, 9, 8, 5, 4, 8, 8, 3, 2, 0, 4},{8, 1, 4, 2, 7, 1, 1, 5, 7, 5, 3, 3, 3, 5, 4, 4, 7, 6, 4, 0}};

//初始化基因(所有基因都保存在genes中)

int i,j;

for(i=0;i<lchrom;i++)

{

genes[i].name =names[i];

for(j=0;j<lchrom;j++)

{

genes[i].linkCost[&genes[j]] = dist[i][j];

}

}

//输出配置信息

cout<<"\n染色体长度:"<<lchrom<<"\n种群大小:"<<popsize<<"\n交叉率:"<<pcross<<"\n变异率:"<<pmutation;

cout<<"\n最大世代数:"<<maxgen<<"\n总运行次数:"<<maxruns<<"\n路径最大连接开销:"<<max_var<<endl;

//输出路径信息

cout<<endl<<" ";

for(i=0;i<lchrom;i++)

cout<<genes[i].name<<" ";

cout<<endl;

for(i=0;i<lchrom;i++)

{

cout<<genes[i].name<<":";

for(j=0;j<lchrom;j++)

{

cout<<genes[i].linkCost[&genes[j]]<<" ";

}

cout<<endl;

}

cout<<endl;

int best;

Chrom bestChrom; //全部种群中最佳染色体

bestChrom.fitness = 0;

float sumVarible = 0;

float sumFitness = 0;

//运行maxrns次

for(run = 1;run<=maxruns;run++)

{

initpop(oldpop); //产生初始种群

//通过不断进化，直到达到最大世代数

for(gen = 1;gen<=maxgen;gen++)

{

generation(oldpop,newpop); //从当前种群产生新种群

oldpop.pop_chrom.swap(newpop.pop_chrom);

oldpop.sumfitness = newpop.sumfitness;

newpop.pop_chrom.clear();

}

best = chooseBest(oldpop); //本次运行得出的最佳染色体

if(oldpop.pop_chrom[best].fitness > bestChrom.fitness)

bestChrom = oldpop.pop_chrom[best];

sumVarible += oldpop.pop_chrom[best].varible;

sumFitness += oldpop.pop_chrom[best].fitness;

cout<<run<<"次"<<"Best:";

outChrom(oldpop.pop_chrom[best]); //输出本次运行得出的最佳染色体

cout<<endl;

oldpop.pop_chrom.clear();

}

cout<<endl<<"一条最佳染色体:";

outChrom(bestChrom); //输出全部种群中最佳染色体

cout<<endl<<endl<<"最佳染色体平均开销:"<<sumVarible/maxruns;

cout<<endl<<"最佳染色体平均适应度:"<<sumFitness/maxruns<<endl;

system("PAUSE");

return 0;

}

上次做大作业的时候做的，可以运行的。有什么问题再问。

⑻ 《系统工程与电子技术》能发表遗传算法的论文吗，老师说算法太旧了

本文在分析现有激光深熔焊接研究成果的基础上，针对现有研究存在的主要问题，采用理论研究和试验研究相结合的方法，对激光深熔焊接过程中的小孔效应进行了较深入系统的研究。
论文首先选择GG17玻璃这种抗热震性好且软化温度与汽化温度相差较远的透明材料作为工件材料，采用特殊设计的实验装置，通过高速摄影方法首次清晰而完整地观测到了激光深熔焊接时的小孔形状。利用针孔扫描的原理，测量了聚焦光斑尺寸及光斑内的能量分布状况。试验研究了离焦量、焊接速度、激光功率等激光焊接工艺参数以及等离子体对激光深熔焊接小孔与熔池形状和尺寸的影响，
结果表明：由于GG17玻璃的热传导系数很小，工件表面处的小孔直径主要取决于有效功率密度下的光斑直径，而与工件表面处的实际光斑直径没有简单的相等或比例关系，并与焊接速度关系不大；小孔的形状呈圆锥形，且圆锥角随小孔深度的增大而减小，当小孔深度较大时，由于不同深度处的小孔直径变化很小，可近似视为一圆柱体；小孔的弯曲程度与焊接速度密切相关，随着焊接速度的增大，小孔的弯曲程度加大；
小孔深度随焊接速度的增大、离焦量的增大以及激光功率的减小而减小；由于GG17玻璃的电离能比金属材料高得多，不易形成光致等离子体，所以，在激光深熔焊接GG17玻璃的过程中，激光能量传输的主要方式是孔壁的多次反射吸收。 其次，论文系统地研究了小孔孔壁的反射吸收在激光深熔焊接过程中对激光能量传输的作用和影响。利用上面得到的小孔照片，通过测量可以确定小孔前后沿的形状，然后通过多项式拟合的方法得到了小孔前后沿的曲线方程。

在实验测量的材料表面对激光的反射率的基础上，采用几何光学近似的方法，通过跟踪激光在小孔内的多次反射传输轨迹，分析和计算了聚焦高斯激光通过孔壁的多次反射吸收而在圆柱形小孔、圆锥形小孔和实际小孔等几种形状的小孔孔壁上的能量分布情况。计算结果表明：不论是圆柱形小孔、圆锥形小孔还是真实形状的小孔，孔壁的多次反射只对小孔下部孔壁上的激光功率密度有影响，而在小孔的上部，孔壁上的激光功率密度主要取决于直射光的功率密度；对于真实形状的弯曲小孔而言，
不论是小孔前沿还是小孔后沿，孔壁上的激光功率密度分布主要取决于直射到小孔前沿的激光功率密度在多次反射后在孔壁上的分布；对于真实形状的弯曲小孔而言，经过孔壁的多次反射吸收以后，小孔前沿孔壁上的激光功率密度基本能均匀分布，但是对于小孔后沿，孔壁上的激光功率密度分布很不均匀

⑼ 学习遗传算法和神经网络算法看什么书好

理论方面用:
<遗传算法---理论,应用与软件实现> 王小平 西安交大出版社
(本人从十本相关书籍中选的一本)
软件实现用:
<MATLAB 遗传算法工具箱及应用> 雷英杰 西安电子科技大学出版社

遗传算法是模仿DNA进化的过程,通过选择,交叉,变异的方法的搜索全局最优解的一种算法,根据你制定的适应度函数,搜索适应度高的基因组合,适应度高的基因组合在下一代所占的比列更高,而适应度低的组合被淘汰.通过一代一代的筛选繁衍,最终找到全局接近最优解.
适用于数值优化，如多目标函数优化。以及组合优化，如NP问题－〉作业调度，旅行问题，背包问题。神经网络是遗传算法的进阶,进一步深入可以解决机器学习与人工智能和生命工程问题.

⑽ 基于遗传算法，用matlab编程，寻找f（x）=x.^2,当x在0~31（整数）区间的最大值用轮盘赌法。可以发我邮箱！

你是西安的么？偶有答案，Hi我。。。
题目：寻找f(x)=x^2，当x在0~31(整数)区间的最大值。这个是老师布置的作业。。