遺傳演算法大作業

⑴ 求一個優化設計解決實際工程問題的案例

比較著名的問題有 背包問題 旅行商問題等，演算法有模擬退火、遺傳演算法等。
想要真實的實際問題 建議你去中國知網搜一搜 應該有好多

⑵ 遺傳演算法具體應用

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(整數)區間的最大值。這個是老師布置的作業。。