遺傳演算法解決路線規劃問題（Vehicle Routing Problem based on GA）
I.問題描述
車輛路徑問題（Vehicle Routing Problem,VRP），車輛路徑問題是一種組合優化問題，它由Dantzig 和 Ramser在1959年共同提出。VRP是指一定數量的客戶，各自有不同數量的貨物需求，配送中心向客戶提供貨物，由一個車隊負責分送貨物，組織適當的行車路線，目標是使得客戶的需求得到滿足，並能在一定的約束下，達到諸如路程最短、成本最小、耗費時間最少等目的。VRP在交通、分配資源和後勤補給方面有很重要的應用。由此定義不難看出，旅行商問題（Traveling Saleman Problem,TSP）是VRP的特例，由於Gaery[2]已證明TSP問題是NP難題，因此，VRP也屬於NP難題。
VRP問題及其一個可行解
II.車輛路徑問題的型別
一般而言車輛路線問題大致可以分為以下三種類型（Ballou，1992）：
1.相異的單一起點和單一終點。
2.相同的單一起點和終點。
3.多個起點和終點。
III.程式程式碼示例
下面這段程式碼描述的是使用遺傳演算法解決相同的單一起點和終點的型別問題的方法。
package com.mnmlist.vrp; /** * @author [email protected] * @date 2015/09/26 * @time 22:24 */ import java.util.Arrays; import java.util.Random; public class VehicleRoutingProblem { static int max = 101; static int maxqvehicle = 1024; static int maxdvehicle = 1024; Random ra = new Random(); int K;// 最多使用車數目 int KK;// 實際使用車數 int clientNum;// 客戶數目,染色體長度 double punishWeight;// W1, W2, W3;//懲罰權重 double crossRate, mutationRate;// 交叉概率和變異概率 int populationScale;// 種群規模 int T;// 進化代數 int t;// 當前代數 int[] bestGhArr;// 所有代數中最好的染色體 double[] timeGhArr;// 所有代數中最好的染色體 double bestFitness;// 所有代數中最好的染色體的適應度 int bestGenerationNum;// 最好的染色體出現的代數 double decodedEvaluation;// 解碼後所有車輛所走路程總和、 double[][] vehicleInfoMatrix;// K下標從1開始到K，0列表示車的最大載重量，1列表示車行駛的最大距離，2列表示速度 int[] decodedArr;// 染色體解碼後表達的每輛車的服務的客戶的順序 double[][] distanceMatrix;// 客戶距離 double[] weightArr;// 客戶需求量 int[][] oldMatrix;// 初始種群，父代種群，行數表示種群規模，一行代表一個個體，即染色體，列表示染色體基因片段 int[][] newMatrix;// 新的種群，子代種群 double[] fitnessArr;// 種群適應度，表示種群中各個個體的適應度 double[] probabilityArr;// 種群中各個個體的累計概率 double[] x1; double[] y1; // 初始化函式 void initData() { int i, j; decodedEvaluation = 0;// 解碼後所有車輛所走路程總和 punishWeight = 300;// 車輛超額懲罰權重 clientNum = 20;// 客戶數目,染色體長度 K = 5;// 最大車數目 populationScale = 100;// 種群規模 crossRate = 0.9;// 交叉概率 mutationRate = 0.09;// 變異概率，實際為(1-Pc)*0.9=0.09 T = 3000;// 進化代數 bestFitness = 0;// 所有代數中最好的染色體的適應度 vehicleInfoMatrix = new double[K + 2][3];// K下標從1開始到K，0列表示車的最大載重量，1列表示車行駛的最大距離，2列表示速度 bestGhArr = new int[clientNum];// 所有代數中最好的染色體 timeGhArr = new double[clientNum];// 所有代數中最好的染色體 decodedArr = new int[clientNum];// 染色體解碼後表達的每輛車的服務的客戶的順序 distanceMatrix = new double[clientNum + 1][clientNum + 1];// 客戶距離 weightArr = new double[clientNum + 1];// 客戶需求量 oldMatrix = new int[populationScale][clientNum];// 初始種群，父代種群，行數表示種群規模，一行代表一個個體，即染色體，列表示染色體基因片段 newMatrix = new int[populationScale][clientNum];// 新的種群，子代種群 fitnessArr = new double[populationScale];// 種群適應度，表示種群中各個個體的適應度 probabilityArr = new double[populationScale];// 種群中各個個體的累計概率 x1 = new double[clientNum + 1]; y1 = new double[clientNum + 1]; // 車輛最大載重和最大行駛 vehicleInfoMatrix[1][0] = 8.0; vehicleInfoMatrix[1][1] = 50.0; vehicleInfoMatrix[2][0] = 8.0; vehicleInfoMatrix[2][1] = 50.0; vehicleInfoMatrix[3][0] = 8.0; vehicleInfoMatrix[3][1] = 50.0; vehicleInfoMatrix[4][0] = 8.0; vehicleInfoMatrix[4][1] = 50.0; vehicleInfoMatrix[5][0] = 8.0; vehicleInfoMatrix[5][1] = 50.0; vehicleInfoMatrix[6][0] = maxqvehicle;// 限制最大 vehicleInfoMatrix[6][1] = maxdvehicle; // 客戶座標 x1[0] = 14.5; y1[0] = 13.0; weightArr[0] = 0.0; x1[1] = 12.8; y1[1] = 8.5; weightArr[1] = 0.1; x1[2] = 18.4; y1[2] = 3.4; weightArr[2] = 0.4; x1[3] = 15.4; y1[3] = 16.6; weightArr[3] = 1.2; x1[4] = 18.9; y1[4] = 15.2; weightArr[4] = 1.5; x1[5] = 15.5; y1[5] = 11.6; weightArr[5] = 0.8; x1[6] = 3.9; y1[6] = 10.6; weightArr[6] = 1.3; x1[7] = 10.6; y1[7] = 7.6; weightArr[7] = 1.7; x1[8] = 8.6; y1[8] = 8.4; weightArr[8] = 0.6; x1[9] = 12.5; y1[9] = 2.1; weightArr[9] = 1.2; x1[10] = 13.8; y1[10] = 15.2; weightArr[10] = 0.4; x1[11] = 6.7; y1[11] = 16.9; weightArr[11] = 0.9; x1[12] = 14.8; y1[12] = 7.6; weightArr[12] = 1.3; x1[13] = 1.8; y1[13] = 8.7; weightArr[13] = 1.3; x1[14] = 17.1; y1[14] = 11.0; weightArr[14] = 1.9; x1[15] = 7.4; y1[15] = 1.0; weightArr[15] = 1.7; x1[16] = 0.2; y1[16] = 2.8; weightArr[16] = 1.1; x1[17] = 11.9; y1[17] = 19.8; weightArr[17] = 1.5; x1[18] = 13.2; y1[18] = 15.1; weightArr[18] = 1.6; x1[19] = 6.4; y1[19] = 5.6; weightArr[19] = 1.7; x1[20] = 9.6; y1[20] = 14.8; weightArr[20] = 1.5; double x = 0, y = 0; // 客戶之間距離 int endIndex = clientNum + 1; for (i = 0; i < endIndex; i++) { for (j = 0; j < endIndex; j++) { x = x1[i] - x1[j]; y = y1[i] - y1[j]; distanceMatrix[i][j] = Math.sqrt(x * x + y * y); } } } // 染色體評價函式，輸入一個染色體，得到該染色體評價值 double caculateFitness(int[] Gh) { // 染色體從下標0開始到L-1； int i, j;// i車的編號，j客戶編號 int flag;// 超額使用的車數 double cur_d, cur_q, evaluation;// 當前車輛行駛距離，載重量，評價值，即各車行駛總里程 cur_d = distanceMatrix[0][Gh[0]];// Gh[0]表示第一個客戶， cur_q = weightArr[Gh[0]]; i = 1;// 從1號車開始，預設第一輛車能滿足第一個客戶的需求 evaluation = 0;// 評價值初始為0 flag = 0;// 表示車輛數未超額 for (j = 1; j < clientNum; j++) { cur_q = cur_q + weightArr[Gh[j]]; cur_d = cur_d + distanceMatrix[Gh[j]][Gh[j - 1]]; // 如果當前客戶需求大於車的最大載重，或者距離大於車行駛最大距離，呼叫下一輛車 if (cur_q > vehicleInfoMatrix[i][0] || cur_d + distanceMatrix[Gh[j]][0] > vehicleInfoMatrix[i][1])// 還得加上返回配送中心距離 { i = i + 1;// 使用下一輛車 evaluation = evaluation + cur_d - distanceMatrix[Gh[j]][Gh[j - 1]] + distanceMatrix[Gh[j - 1]][0]; cur_d = distanceMatrix[0][Gh[j]];// 從配送中心到當前客戶j距離 cur_q = weightArr[Gh[j]]; } } evaluation = evaluation + cur_d + distanceMatrix[Gh[clientNum - 1]][0];// 加上最後一輛車走的距離 flag = i - K;// 看車輛使用數目是否大於規定車數，最多隻超一輛車 if (flag < 0) flag = 0;// 不大於則不懲罰 evaluation = evaluation + flag * punishWeight;// 超額車數乘以懲罰權重 return 10 / evaluation;// 壓縮評價值 } // 染色體解碼函式，輸入一個染色體，得到該染色體表達的每輛車的服務的客戶的順序 void decoding(int[] Gh) { // 染色體從下標0開始到L-1； int i, j;// i車的編號，j客戶編號 double cur_d, cur_q, evaluation;// 當前車輛行駛距離，載重量，評價值，即各車行駛總里程 cur_d = distanceMatrix[0][Gh[0]];// Gh[0]表示第一個客戶， cur_q = weightArr[Gh[0]]; i = 1;// 從1號車開始，預設第一輛車能滿足第一個客戶的需求 decodedArr[i] = 1; evaluation = 0; for (j = 1; j < clientNum; j++) { cur_q = cur_q + weightArr[Gh[j]]; cur_d = cur_d + distanceMatrix[Gh[j]][Gh[j - 1]]; // 如果當前客戶需求大於車的最大載重，或者距離大於車行駛最大距離，呼叫下一輛車 if (cur_q > vehicleInfoMatrix[i][0] || cur_d + distanceMatrix[Gh[j]][0] > vehicleInfoMatrix[i][1]) { i = i + 1;// 使用下一輛車 decodedArr[i] = decodedArr[i - 1] + 1;// evaluation = evaluation + cur_d - distanceMatrix[Gh[j]][Gh[j - 1]] + distanceMatrix[Gh[j - 1]][0]; cur_d = distanceMatrix[0][Gh[j]];// 從配送中心到當前客戶j距離 cur_q = weightArr[Gh[j]]; } else { decodedArr[i] = decodedArr[i] + 1;// } } decodedEvaluation = evaluation + cur_d + distanceMatrix[Gh[clientNum - 1]][0];// 加上最後一輛車走的距離 KK = i; } // 初始化種群 void initGroup() { int i, k; int randomNum = 0; for (k = 0; k < populationScale; k++)// 種群數 { for (i = 0; i < clientNum; i++) oldMatrix[k][i] = i + 1; for (i = 0; i < clientNum; i++) { randomNum = ra.nextInt(clientNum); swap(oldMatrix[k], i, randomNum); } } // 顯示初始化種群 // System.out.println("///////////////顯示初始種群開始(In initGroup method)////////////////////"); // for (k = 0; k < populationScale; k++) // System.out.println(Arrays.toString(oldMatrix[k])); // System.out.println("///////////////顯示初始種群結束////////////////////"); } public void swap(int arr[], int index1, int index2) { int temp = arr[index1]; arr[index1] = arr[index2]; arr[index2] = temp; } // 計算種群中各個個體的累積概率，前提是已經計算出各個個體的適應度Fitness[max]，作為賭輪選擇策略一部分，Pi[max] void countRate() { int k; double sumFitness = 0;// 適應度總和 for (k = 0; k < populationScale; k++) { sumFitness += fitnessArr[k]; } // 計算各個個體累計概率 probabilityArr[0] = fitnessArr[0] / sumFitness; for (k = 1; k < populationScale; k++) { probabilityArr[k] = fitnessArr[k] / sumFitness + probabilityArr[k - 1]; } } // 複製染色體，k表示新染色體在種群中的位置，kk表示舊的染色體在種群中的位置 void copyChrosome(int k, int kk) { System.arraycopy(oldMatrix[kk], 0, newMatrix[k], 0, clientNum); } // 挑選某代種群中適應度最高的個體，直接複製到子代中，前提是已經計算出各個個體的適應度Fitness[max] void selectBestChrosome() { int k, maxid; double maxevaluation; maxid = 0; maxevaluation = fitnessArr[0]; for (k = 1; k < populationScale; k++) { if (maxevaluation < fitnessArr[k]) { maxevaluation = fitnessArr[k]; maxid = k; } } if (bestFitness < maxevaluation) { bestFitness = maxevaluation; bestGenerationNum = t;// 最好的染色體出現的代數; System.arraycopy(oldMatrix[maxid], 0, bestGhArr, 0, clientNum); } // 複製染色體，k表示新染色體在種群中的位置，kk表示舊的染色體在種群中的位置 copyChrosome(0, maxid);// 將當代種群中適應度最高的染色體k複製到新種群中，排在第一位0 } // 產生隨機數 int select() { int k; double ran1; ran1 = Math.abs(ra.nextDouble()); for (k = 0; k < populationScale; k++) { if (ran1 <= probabilityArr[k]) { break; } } return k; } // 類OX交叉運算元,交叉運算元不夠優秀 void oxCrossover(int k1, int k2) { int i, j, k, flag; int ran1, ran2, temp; int[] Gh1 = new int[clientNum]; int[] Gh2 = new int[clientNum]; ran1 = ra.nextInt(clientNum); ran2 = ra.nextInt(clientNum); while (ran1 == ran2) ran2 = ra.nextInt(clientNum); if (ran1 > ran2)// 確保ran1<ran2 { temp = ran1; ran1 = ran2; ran2 = temp; } flag = ran2 - ran1 + 1;// 刪除重複基因前染色體長度 for (i = 0, j = ran1; i < flag; i++, j++) { Gh1[i] = newMatrix[k2][j]; Gh2[i] = newMatrix[k1][j]; } // 已近賦值i=ran2-ran1個基因 for (k = 0, j = flag; j < clientNum; j++)// 染色體長度 { i = 0; while (i != flag) { Gh1[j] = newMatrix[k1][k++]; i = 0; while (i < flag && Gh1[i] != Gh1[j]) i++; } } for (k = 0, j = flag; j < clientNum; j++)// 染色體長度 { i = 0; while (i != flag) { Gh2[j] = newMatrix[k2][k++]; i = 0; while (i < flag && Gh2[i] != Gh2[j]) i++; } } System.arraycopy(Gh1, 0, newMatrix[k1], 0, clientNum); System.arraycopy(Gh2, 0, newMatrix[k2], 0, clientNum); } // 對種群中的第k個染色體進行變異 void mutation(int k) { int ran1, ran2; ran1 = ra.nextInt(clientNum); ran2 = ra.nextInt(clientNum); while (ran1 == ran2) ran2 = ra.nextInt(clientNum); swap(newMatrix[k], ran1, ran2); } // 進化函式，保留最優 void evolution() { int k, selectId; double r;// 大於0小於1的隨機數 // 挑選某代種群中適應度最高的個體 selectBestChrosome(); // 賭輪選擇策略挑選scale-1個下一代個體 for (k = 1; k < populationScale; k++) { selectId = select(); copyChrosome(k, selectId); } for (k = 1; k + 1 < populationScale / 2; k = k + 2) { r = Math.abs(ra.nextDouble()); // crossover if (r < crossRate) { oxCrossover(k, k + 1);// 進行交叉 } else { r = Math.abs(ra.nextDouble()); if (r < mutationRate) { mutation(k); } r = Math.abs(ra.nextDouble()); if (r < mutationRate) { mutation(k + 1); } } } if (k == populationScale / 2 - 1)// 剩最後一個染色體沒有交叉L-1 { r = Math.abs(ra.nextDouble()); if (r < mutationRate) { mutation(k); } } } public BestResult solveVrp() { int i, j, k; BestResult bestResult = new BestResult(); // 初始化資料，不同問題初始化資料不一樣 initData(); // 初始化種群 initGroup(); int[] tempGA = new int[clientNum]; // 計算初始化種群適應度，Fitness[max] for (k = 0; k < populationScale; k++) { for (i = 0; i < clientNum; i++) { tempGA[i] = oldMatrix[k][i]; } fitnessArr[k] = caculateFitness(tempGA); } // 計算初始化種群中各個個體的累積概率，Pi[max] countRate(); for (t = 0; t < T; t++) { evolution();// 進化函式，保留最優 // 將新種群newMatrix複製到舊種群oldMatrix中，準備下一代進化 for (k = 0; k < populationScale; k++) System.arraycopy(newMatrix[k], 0, oldMatrix[k], 0, clientNum); // 計算種群適應度，Fitness[max] for (k = 0; k < populationScale; k++) { System.arraycopy(oldMatrix[k], 0, tempGA, 0, clientNum); fitnessArr[k] = caculateFitness(tempGA); } // 計算種群中各個個體的累積概率，Pi[max] countRate(); // 進度條 } // 最後種群 // System.out.println("//////////////////////////////////"); // for (k = 0; k < populationScale; k++) // System.out.println(Arrays.toString(oldMatrix[k])); // System.out.println("\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\t"); // 出現代數 System.out.println("最好的代數出現在：" + bestGenerationNum + "代"); // 染色體評價值 System.out.println("最好的結果為：" + (10 / bestFitness) + "或" + bestFitness); // 最好的染色體 System.out.println(Arrays.toString(bestGhArr)); // 最好的染色體解碼 decoding(bestGhArr); // 使用車數 System.out.println("使用車數：" + KK); // 解碼 System.out.println("車輛解碼：" + Arrays.toString(decodedArr)); System.out.println("車輛行駛距離解碼：" + decodedEvaluation); String tefa = ""; int tek; int[] templ = new int[max]; for (i = 1; i <= KK; i++) { templ[1] = 0; tefa = "0-"; tek = decodedArr[i - 1]; for (j = tek, k = 2; j < decodedArr[i]; j++, k++) { tefa = tefa + bestGhArr[j] + "-"; templ[k] = bestGhArr[j]; } templ[k] = 0; templ[0] = k; tefa = k + "-" + tefa + "0"; System.out.println(tefa); } bestResult.setBestFitness(10 / bestFitness); bestResult.setBestGenerationNum(bestGenerationNum); return bestResult; } public static void main(String[] args) { VehicleRoutingProblem vehicleRoutingProblem = new VehicleRoutingProblem(); int count = 50; double generationNum = 0; double totalFitness = 0; BestResult bestResult = null; for (int i = 0; i < count; i++) { System.out.println( "/////////the " + (i + 1) + "iteration start...////////"); bestResult = vehicleRoutingProblem.solveVrp(); totalFitness += bestResult.getBestFitness(); generationNum += bestResult.getBestGenerationNum(); System.out.println( "/////////the " + (i + 1) + "iteration end...////////"); System.out.println(); } System.out.println("平均在第" + (generationNum / count) + "代找到最有解。"); System.out.println("平均的路成為：" + (totalFitness / count)); } } class BestResult { private double bestFitness; private int bestGenerationNum; public int getBestGenerationNum() { return bestGenerationNum; } public void setBestGenerationNum(int bestGenerationNum) { this.bestGenerationNum = bestGenerationNum; } public double getBestFitness() { return bestFitness; } public void setBestFitness(double bestFitness) { this.bestFitness = bestFitness; } }
相關推薦
遺傳演算法解決路線規劃問題（Vehicle Routing Problem based on GA）
I.問題描述 車輛路徑問題（Vehicle Routing Problem,VRP），車輛路徑問題是一種組合優化問題，它由Dantzig 和 Ramser在1959年共同提出。VRP是指一定數量的客戶，各自有不同數量的貨物需求，配送中心向客戶提供貨物，由一個車隊負責分送貨物
【高階演算法】遺傳演算法解決3SAT問題（C++實現）
1 SAT問題描述 命題邏輯中合取正規化 (CNF) 的可滿足性問題 (SAT)是當代理論電腦科學的核心問題, 是一典型的NP 完全問題.在定義可滿足性問題SAT之前，先引進一些邏輯符號。 一個 SAT 問題是指: 對於給定的 CNF 是否存在一
matlab手寫遺傳演算法解決一元函式最值問題（例項）
問題：找出y=x4-4x3+3x+5 （xÎ[0,6]）在[0,6]之間的最小值。 思路：用33位0，1變數來編碼x,3位編碼整數，30位編碼小數。理論上30位編碼小數可以將最小值對應的x精確到小數點後九位. 下面是我解決這個問題所有的函式，複製就可以運行了，不明白可以私
遺傳演算法解決TSP旅行商問題（附：Python實現）
前言 我先囉嗦一下：不是很喜歡寫計算智慧的演算法，因為一個演算法就要寫好久。前前後後將近有兩天的時間。 好啦，現在進入正題。 巡迴旅行商問題(TSP)是一個組合優化方面的問題，已經成為測試組合優化新演算法的標準問題。應用遺傳演算法解決 TSP 問題，首先對訪問
物流路徑規劃用遺傳演算法解決例項
網上有很多關於遺傳演算法的教程，但基本千篇一律。這次物流課做了一個跟路徑規劃相關的案例，拿出來與大家分享。 先貼案例。案例摘自《企業物流管理》。 《 R&T批發公司》 R&T批發公司給全印度的零售商批發日用商品。公司在全國有很
遺傳演算法解決迷宮尋路問題（Java實現）
1.什麼是遺傳演算法？ 就個人理解，遺傳演算法是模擬神奇的大自然中生物“優勝劣汰”原則指導下的進化過程，好的基因有更多的機會得到繁衍，這樣一來，隨著繁衍的進行，生物種群會朝著一個趨勢收斂。而生物繁衍過程中的基因雜交和變異會給種群提供更好的基因序列，這樣種群的繁
【搞搞演算法】用遺傳演算法解決多目標規劃問題_論文閱讀筆記
這是2014年4月在其他部落格寫的，轉帖到CSDN的部落格上。 許老師給了很多多目標GA的論文，全英文讀起來比較慢，用Google翻譯+靈格斯詞典解決了詞彙問題，理解起來並不是很難，這也是GA演算法的特點——演算法本身容易理解，演算法知識不全的人（比如我）也能比較快地運用
MATLAB（1）基於遺傳演算法解決最優化問題及相應的MATLAB遺傳工具箱使用
對於取最小值的最優化問題，遺傳演算法借鑑生物遺傳現象使具有一定數量的候選解的種群向更好的解進化，該方法是通過種群進化，使得適應度函式代入估計引數後達到最值來得到最優解。借鑑生物種群的進化，遺傳演算法先隨機產生一組初始解，作為初始種群，以數值解為例，這些解都是通過二進位制程式碼儲存在計算機中，類似於染
微信小程序 - 輸入起點、終點獲取距離並且進行路線規劃（騰訊地圖）
img -c con XML family maps option space com index.wxml <!--地圖容器--> <map id="myMap" style="width: 100%; height: 300px;"
遺傳演算法解決推箱子問題
遺傳演算法 遺傳演算法（Genetic Algorithm）是一類借鑑生物界的進化規律（適者生存，優勝劣汰遺傳機制）演化而來的隨機化搜尋方法。最早聽說這個演算法是在一門公選課上，當時瞭解的還包括蟻群演算法等。總之，這種演算法通過模擬自然界物種的繁衍，來尋找適宜生存的種群，達到尋找相
遺傳演算法解決尋路問題——Python描述
概要 我的上一篇寫遺傳演算法解決排序問題，當中思想借鑑了遺傳演算法解決TSP問題，本質上可以認為這是一類問題，就是這樣認為：尋找到一個序列X，使F（X）最大。 詳解介紹 排序問題：尋找一個序列，使得這個序列的逆序對的倒數最大。 TSP問題：尋找一個序列，使得這個序列的總路徑長的倒數最大。 這兩個問題
演算法基礎--動態規劃（筆試記錄）
#include<iostream> using namespace std; int main() { //輸入部分 //輸入寶箱的個數n，和現在還剩餘的魔法值w int n,w; cin>>n>>w; //int n = 5,w = 10;
由Leetcode詳解演算法 之 動態規劃（DP）
因為最近一段時間接觸了一些Leetcode上的題目，發現許多題目的解題思路相似，從中其實可以瞭解某類演算法的一些應用場景。 這個隨筆系列就是我嘗試的分析總結，希望也能給大家一些啟發。 動態規劃的基本概念 一言以蔽之，動態規劃就是將大問題分成小問題，以迭代的方式求解。 可以使用動態規劃求解的問題
數學建模 of python(用遺傳演算法解決TSP問題)
吉吉： 在這個問題中，我們的個體就是一條一條的路線了，其目的就是找到一條總距離最短的路線。基本步驟與前兩篇文章基本類似，不過在本問題中，我們用城市路線中每個城市的經緯度來表示個體(城市路線)的DNA。 在產生後代的過程中，需要注意的是，因為我們的個體是路線，所以不能將兩個
Python遺傳演算法框架使用例項（二）多目標優化問題Geatpy for Python與Matlab的對比學習
在前面幾篇文章中，我們已經介紹了高效能Python遺傳和進化演算法框架——Geatpy的使用及一些案例。 本篇就一個多目標優化例項進行展開講述，並且與使用Matlab工具箱得到相近效果進行一些對比： Geatpy已於2018.09.20更新至1.0.6版本
遺傳演算法解決單變數函式值得優化問題
最近稍微學習一下智慧演算法的設計，就滿Internet搜尋，最終發現遺傳演算法是大家學習最多的，也是在各個領域內進行函式優化，解析解求解過程中很重要的一種方法！ 學習遺傳演算法，首先為了上手較快，我推薦大家先使用Matlab，這個工具進行矩陣分析有應用，真的很管
初學遺傳演算法解決tsp問題(C++)
前言 斷斷續續學遺傳到現在快一個禮拜了，之前一直在看思想，死想活想，始終不敢去自己程式碼實現。 今天硬著頭皮開始寫，寫不下去就找博文看，總算是初步的實現了，邁出了智慧演算法學習的第一小步，心情不可謂不激動。 好吧，說正經的。 tsp&
使用遺傳演算法解決多變數函式優化問題！
很多朋友在碰到多變數值優化的問題的時候不能很好的將問題轉化，利用有效編碼的方法將解的個數，解的編碼很好的很合理的進行設計，因此不能利用遺傳演算法進行問題的求解！ 其實，簡單的來說，就是將多個變數的數值編碼編排進去，進行組合，只需要增長基因個體的
遺傳演算法解決TSP問題
讀了原作者mylovestart用遺傳演算法實現的tsp問題，學習了ga演算法。 但發現原作者mylovestart的jiaopei()函式寫的有問題，交叉後要確保每個城市有且僅走了一次，修改了jiaopei()的程式碼如下： //交配,對每個染色體產生交配概率,滿足交配
遺傳演算法解決TSP問題實現以及與最小生成樹的對比
摘要： 本實驗採用遺傳演算法實現了旅行商問題的模擬求解，並在同等規模問題上用最小生成樹演算法做了一定的對比工作。遺傳演算法在計算時間和佔用記憶體上，都遠遠優於最小生成樹演算法。 程式採用Microsoft visual studio 2008 結合MFC基本對話方塊類庫開發。32位windows 7系統下除