遗传算法解决旅行商问题JAVA

转载自：wangqiuyun

原文链接：http://blog.csdn.net/wangqiuyun/article/details/12838903

一、TSP问题

TSP问题（Travelling Salesman Problem）即旅行商问题，又译为旅行推销员问题、货郎担问题，是数学领域中著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是要求得的路径路程为所有路径之中的最小值。

TSP问题是一个组合优化问题。该问题可以被证明具有NPC计算复杂性。TSP问题可以分为两类，一类是对称TSP问题（Symmetric TSP），另一类是非对称问题（Asymmetric TSP）。所有的TSP问题都可以用一个图（Graph）来描述：

V={c1, c2, …, ci, …, cn}，i = 1,2, …, n，是所有城市的集合.ci表示第i个城市，n为城市的数目；

E={(r, s): r,s∈ V}是所有城市之间连接的集合；

C = {crs: r,s∈ V}是所有城市之间连接的成本度量（一般为城市之间的距离）；

如果crs = csr, 那么该TSP问题为对称的，否则为非对称的。

一个TSP问题可以表达为：

求解遍历图G = (V, E, C)，所有的节点一次并且回到起始节点，使得连接这些节点的路径成本最低。

二、遗传算法

遗传算法（Genetic Algorithms ）是基于生物进化理论的原理发展起来的一种广为应用的、高效的随机搜索与优化的方法。其主要特点是群体搜索策略和群体中个体之间的信息交换，搜索不依赖于梯度信息。它是在70年代初期由美国密西根（ Michigan ）大学的霍兰（ Holland ）教授发展起来的。1975年霍兰教授发表了第一本比较系统论述遗传算法的专著《自然系统与人工系统中的适应性》（《 Adaptationin Natural and Artificial Systems 》）。遗传算法最初被研究的出发点不是为专门解决最优化问题而设计的，它与进化策略、进化规划共同构成了进化算法的主要框架，都是为当时人工智能的发展服务的。迄今为止，遗传算法是进化算法中最广为人知的算法。

 遗传火算法的实施步骤如下（以目标函数求最小为例）。
    第一步：初始化 t←0进化代数计数器；T是最大进化代数；随机生成M个个体作为初始群体P（t）；
    第二步：个体评价 计算P（t）中各个个体的适应度；
    第三步：选择运算 将选择算子作用于群体；
    第四步：交叉运算 将交叉算子作用于群体；
    第五步：变异运算 将变异算子作用于群体，并通过以上运算得到下一代群体P（t + 1）;
    第六步：终止条件判断  t≦T：t← t+1 转到步骤2；t>T：终止 输出解。

遗传算法应用步骤：
    1）确定决策变量及各种约束条件，即个体的表现型X和问题的解空间；
    2）建立优化模型 （目标函数最大OR 最小） 数学描述形式 量化方法；
    3）染色体编码方法；
    4）解码方法；
    5）个体适应度的量化评价方法 F(x)
    6）设计遗传算子；
    7）确定有关运行参数。

三、遗传算法求解TSP问题

其实之前不大想写这个遗传算法求TSP，因为我之前已经有遗传算法求01背包了，但有些读者建议，加上确实tsp与01背包差别还是很大的，就再写一个。对于TSP之类的问题NP问题，使用启发式搜索算法是一个明智的选择，因为精确算发已经力不从心了。

使用遗传算法第一件事情就是确定染色编码方式，它根据不同的问题模型使用不同编码方式，有二进制编码也有整数编码和浮点数编码，面对TSP问题，我肯定选用整数编码，因为很简单，对于每个城市用一个整数来编号，例如有48个城市，就用0到47来标识每一个城市，然后一个路径就是一条染色体编码，染色体长度为48，如：0,1,2,3,4...47就是一个染色体，它表达的意思就是旅行者从0号城市出发，依次访问1,2,...47号城市再回到0号城市；遗传算法的第二个要点就是评价函数，TSP的评价函数很简单，就是染色体编码表达的路径总长度；最后很简单，其实在这个模型中就是将0到47这48个数进行全排列，从中找出最短的一条路径（想想48个数全排列，然后比较。。。）。清楚了解了这些，咱们就可以按照上面的遗传算法框架来进行编程了。

我们使用TSP问题依然来自于tsplib上的数据att48，这是一个对称TSP问题，城市规模为48，其最优值为10628.其距离计算方法下图所示：

具体代码如下：

[java]  view plain  copy

1. package noah;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.FileInputStream;  
5. import java.io.IOException;  
6. import java.io.InputStreamReader;  
7. import java.util.Random;  
8.   
9. public class GA {  
10.   
11.     private int scale;// 种群规模  
12.     private int cityNum; // 城市数量，染色体长度  
13.     private int MAX_GEN; // 运行代数  
14.     private int[][] distance; // 距离矩阵  
15.     private int bestT;// 最佳出现代数  
16.     private int bestLength; // 最佳长度  
17.     private int[] bestTour; // 最佳路径  
18.   
19.     // 初始种群，父代种群，行数表示种群规模，一行代表一个个体，即染色体，列表示染色体基因片段  
20.     private int[][] oldPopulation;  
21.     private int[][] newPopulation;// 新的种群，子代种群  
22.     private int[] fitness;// 种群适应度，表示种群中各个个体的适应度  
23.   
24.     private float[] Pi;// 种群中各个个体的累计概率  
25.     private float Pc;// 交叉概率  
26.     private float Pm;// 变异概率  
27.     private int t;// 当前代数  
28.   
29.     private Random random;  
30.   
31.     public GA() {  
32.   
33.     }  
34.   
35.     /** 
36.      * constructor of GA 
37.      *  
38.      * @param s 
39.      *            种群规模 
40.      * @param n 
41.      *            城市数量 
42.      * @param g 
43.      *            运行代数 
44.      * @param c 
45.      *            交叉率 
46.      * @param m 
47.      *            变异率 
48.      *  
49.      **/  
50.     public GA(int s, int n, int g, float c, float m) {  
51.         scale = s;  
52.         cityNum = n;  
53.         MAX_GEN = g;  
54.         Pc = c;  
55.         Pm = m;  
56.     }  
57.   
58.     // 给编译器一条指令，告诉它对被批注的代码元素内部的某些警告保持静默  
59.     @SuppressWarnings("resource")  
60.     /** 
61.      * 初始化GA算法类 
62.      * @param filename 数据文件名，该文件存储所有城市节点坐标数据 
63.      * @throws IOException 
64.      */  
65.     private void init(String filename) throws IOException {  
66.         // 读取数据  
67.         int[] x;  
68.         int[] y;  
69.         String strbuff;  
70.         BufferedReader data = new BufferedReader(new InputStreamReader(  
71.                 new FileInputStream(filename)));  
72.         distance = new int[cityNum][cityNum];  
73.         x = new int[cityNum];  
74.         y = new int[cityNum];  
75.         for (int i = 0; i < cityNum; i++) {  
76.             // 读取一行数据，数据格式1 6734 1453  
77.             strbuff = data.readLine();  
78.             // 字符分割  
79.             String[] strcol = strbuff.split(" ");  
80.             x[i] = Integer.valueOf(strcol[1]);// x坐标  
81.             y[i] = Integer.valueOf(strcol[2]);// y坐标  
82.         }  
83.         // 计算距离矩阵  
84.         // ，针对具体问题，距离计算方法也不一样，此处用的是att48作为案例，它有48个城市，距离计算方法为伪欧氏距离，最优值为10628  
85.         for (int i = 0; i < cityNum - 1; i++) {  
86.             distance[i][i] = 0; // 对角线为0  
87.             for (int j = i + 1; j < cityNum; j++) {  
88.                 double rij = Math  
89.                         .sqrt(((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j])  
90.                                 * (y[i] - y[j])) / 10.0);  
91.                 // 四舍五入，取整  
92.                 int tij = (int) Math.round(rij);  
93.                 if (tij < rij) {  
94.                     distance[i][j] = tij + 1;  
95.                     distance[j][i] = distance[i][j];  
96.                 } else {  
97.                     distance[i][j] = tij;  
98.                     distance[j][i] = distance[i][j];  
99.                 }  
100.             }  
101.         }  
102.         distance[cityNum - 1][cityNum - 1] = 0;  
103.   
104.         bestLength = Integer.MAX_VALUE;  
105.         bestTour = new int[cityNum + 1];  
106.         bestT = 0;  
107.         t = 0;  
108.   
109.         newPopulation = new int[scale][cityNum];  
110.         oldPopulation = new int[scale][cityNum];  
111.         fitness = new int[scale];  
112.         Pi = new float[scale];  
113.   
114.         random = new Random(System.currentTimeMillis());  
115.         /* 
116.          * for(int i=0;i<cityNum;i++) { for(int j=0;j<cityNum;j++) { 
117.          * System.out.print(distance[i][j]+","); } System.out.println(); } 
118.          */  
119.         // 初始化种群  
120.   
121.     }  
122.   
123.     // 初始化种群  
124.     void initGroup() {  
125.         int i, j, k;  
126.         // Random random = new Random(System.currentTimeMillis());  
127.         for (k = 0; k < scale; k++)// 种群数  
128.         {  
129.             oldPopulation[k][0] = random.nextInt(65535) % cityNum;  
130.             for (i = 1; i < cityNum;)// 染色体长度  
131.             {  
132.                 oldPopulation[k][i] = random.nextInt(65535) % cityNum;  
133.                 for (j = 0; j < i; j++) {  
134.                     if (oldPopulation[k][i] == oldPopulation[k][j]) {  
135.                         break;  
136.                     }  
137.                 }  
138.                 if (j == i) {  
139.                     i++;  
140.                 }  
141.             }  
142.         }  
143.   
144.         /* 
145.          * for(i=0;i<scale;i++) { for(j=0;j<cityNum;j++) { 
146.          * System.out.print(oldPopulation[i][j]+","); } System.out.println(); } 
147.          */  
148.     }  
149.   
150.     public int evaluate(int[] chromosome) {  
151.         // 0123  
152.         int len = 0;  
153.         // 染色体，起始城市,城市1,城市2...城市n  
154.         for (int i = 1; i < cityNum; i++) {  
155.             len += distance[chromosome[i - 1]][chromosome[i]];  
156.         }  
157.         // 城市n,起始城市  
158.         len += distance[chromosome[cityNum - 1]][chromosome[0]];  
159.         return len;  
160.     }  
161.   
162.     // 计算种群中各个个体的累积概率，前提是已经计算出各个个体的适应度fitness[max]，作为赌轮选择策略一部分，Pi[max]  
163.     void countRate() {  
164.         int k;  
165.         double sumFitness = 0;// 适应度总和  
166.   
167.         double[] tempf = new double[scale];  
168.   
169.         for (k = 0; k < scale; k++) {  
170.             tempf[k] = 10.0 / fitness[k];  
171.             sumFitness += tempf[k];  
172.         }  
173.   
174.         Pi[0] = (float) (tempf[0] / sumFitness);  
175.         for (k = 1; k < scale; k++) {  
176.             Pi[k] = (float) (tempf[k] / sumFitness + Pi[k - 1]);  
177.         }  
178.   
179.         /* 
180.          * for(k=0;k<scale;k++) { System.out.println(fitness[k]+" "+Pi[k]); } 
181.          */  
182.     }  
183.   
184.     // 挑选某代种群中适应度最高的个体，直接复制到子代中  
185.     // 前提是已经计算出各个个体的适应度Fitness[max]  
186.     public void selectBestGh() {  
187.         int k, i, maxid;  
188.         int maxevaluation;  
189.   
190.         maxid = 0;  
191.         maxevaluation = fitness[0];  
192.         for (k = 1; k < scale; k++) {  
193.             if (maxevaluation > fitness[k]) {  
194.                 maxevaluation = fitness[k];  
195.                 maxid = k;  
196.             }  
197.         }  
198.   
199.         if (bestLength > maxevaluation) {  
200.             bestLength = maxevaluation;  
201.             bestT = t;// 最好的染色体出现的代数;  
202.             for (i = 0; i < cityNum; i++) {  
203.                 bestTour[i] = oldPopulation[maxid][i];  
204.             }  
205.         }  
206.   
207.         // System.out.println("代数 " + t + " " + maxevaluation);  
208.         // 复制染色体，k表示新染色体在种群中的位置，kk表示旧的染色体在种群中的位置  
209.         copyGh(0, maxid);// 将当代种群中适应度最高的染色体k复制到新种群中，排在第一位0  
210.     }  
211.   
212.     // 复制染色体，k表示新染色体在种群中的位置，kk表示旧的染色体在种群中的位置  
213.     public void copyGh(int k, int kk) {  
214.         int i;  
215.         for (i = 0; i < cityNum; i++) {  
216.             newPopulation[k][i] = oldPopulation[kk][i];  
217.         }  
218.     }  
219.   
220.     // 赌轮选择策略挑选  
221.     public void select() {  
222.         int k, i, selectId;  
223.         float ran1;  
224.         // Random random = new Random(System.currentTimeMillis());  
225.         for (k = 1; k < scale; k++) {  
226.             ran1 = (float) (random.nextInt(65535) % 1000 / 1000.0);  
227.             // System.out.println("概率"+ran1);  
228.             // 产生方式  
229.             for (i = 0; i < scale; i++) {  
230.                 if (ran1 <= Pi[i]) {  
231.                     break;  
232.                 }  
233.             }  
234.             selectId = i;  
235.             // System.out.println("选中" + selectId);  
236.             copyGh(k, selectId);  
237.         }  
238.     }  
239.   
240.     //进化函数，正常交叉变异  
241.     public void evolution() {  
242.         int k;  
243.         // 挑选某代种群中适应度最高的个体  
244.         selectBestGh();  
245.   
246.         // 赌轮选择策略挑选scale-1个下一代个体  
247.         select();  
248.   
249.         // Random random = new Random(System.currentTimeMillis());  
250.         float r;  
251.   
252.         // 交叉方法  
253.         for (k = 0; k < scale; k = k + 2) {  
254.             r = random.nextFloat();// /产生概率  
255.             // System.out.println("交叉率..." + r);  
256.             if (r < Pc) {  
257.                 // System.out.println(k + "与" + k + 1 + "进行交叉...");  
258.                 //OXCross(k, k + 1);// 进行交叉  
259.                 OXCross1(k, k + 1);  
260.             } else {  
261.                 r = random.nextFloat();// /产生概率  
262.                 // System.out.println("变异率1..." + r);  
263.                 // 变异  
264.                 if (r < Pm) {  
265.                     // System.out.println(k + "变异...");  
266.                     OnCVariation(k);  
267.                 }  
268.                 r = random.nextFloat();// /产生概率  
269.                 // System.out.println("变异率2..." + r);  
270.                 // 变异  
271.                 if (r < Pm) {  
272.                     // System.out.println(k + 1 + "变异...");  
273.                     OnCVariation(k + 1);  
274.                 }  
275.             }  
276.   
277.         }  
278.     }  
279.   
280.     //进化函数，保留最好染色体不进行交叉变异  
281.     public void evolution1() {  
282.         int k;  
283.         // 挑选某代种群中适应度最高的个体  
284.         selectBestGh();  
285.   
286.         // 赌轮选择策略挑选scale-1个下一代个体  
287.         select();  
288.   
289.         // Random random = new Random(System.currentTimeMillis());  
290.         float r;  
291.   
292.         for (k = 1; k + 1 < scale / 2; k = k + 2) {  
293.             r = random.nextFloat();// /产生概率  
294.             if (r < Pc) {  
295.                 OXCross1(k, k + 1);// 进行交叉  
296.                 //OXCross(k,k+1);//进行交叉  
297.             } else {  
298.                 r = random.nextFloat();// /产生概率  
299.                 // 变异  
300.                 if (r < Pm) {  
301.                     OnCVariation(k);  
302.                 }  
303.                 r = random.nextFloat();// /产生概率  
304.                 // 变异  
305.                 if (r < Pm) {  
306.                     OnCVariation(k + 1);  
307.                 }  
308.             }  
309.         }  
310.         if (k == scale / 2 - 1)// 剩最后一个染色体没有交叉L-1  
311.         {  
312.             r = random.nextFloat();// /产生概率  
313.             if (r < Pm) {  
314.                 OnCVariation(k);  
315.             }  
316.         }  
317.   
318.     }  
319.   
320.     // 类OX交叉算子  
321.     void OXCross(int k1, int k2) {  
322.         int i, j, k, flag;  
323.         int ran1, ran2, temp;  
324.         int[] Gh1 = new int[cityNum];  
325.         int[] Gh2 = new int[cityNum];  
326.         // Random random = new Random(System.currentTimeMillis());  
327.   
328.         ran1 = random.nextInt(65535) % cityNum;  
329.         ran2 = random.nextInt(65535) % cityNum;  
330.         // System.out.println();  
331.         // System.out.println("-----------------------");  
332.         // System.out.println("----"+ran1+"----"+ran2);  
333.   
334.         while (ran1 == ran2) {  
335.             ran2 = random.nextInt(65535) % cityNum;  
336.         }  
337.   
338.         if (ran1 > ran2)// 确保ran1<ran2  
339.         {  
340.             temp = ran1;  
341.             ran1 = ran2;  
342.             ran2 = temp;  
343.         }  
344.         // System.out.println();  
345.         // System.out.println("-----------------------");  
346.         // System.out.println("----"+ran1+"----"+ran2);  
347.         // System.out.println("-----------------------");  
348.         // System.out.println();  
349.         flag = ran2 - ran1 + 1;// 删除重复基因前染色体长度  
350.         for (i = 0, j = ran1; i < flag; i++, j++) {  
351.             Gh1[i] = newPopulation[k2][j];  
352.             Gh2[i] = newPopulation[k1][j];  
353.         }  
354.         // 已近赋值i=ran2-ran1个基因  
355.   
356.         for (k = 0, j = flag; j < cityNum;)// 染色体长度  
357.         {  
358.             Gh1[j] = newPopulation[k1][k++];  
359.             for (i = 0; i < flag; i++) {  
360.                 if (Gh1[i] == Gh1[j]) {  
361.                     break;  
362.                 }  
363.             }  
364.             if (i == flag) {  
365.                 j++;  
366.             }  
367.         }  
368.   
369.         for (k = 0, j = flag; j < cityNum;)// 染色体长度  
370.         {  
371.             Gh2[j] = newPopulation[k2][k++];  
372.             for (i = 0; i < flag; i++) {  
373.                 if (Gh2[i] == Gh2[j]) {  
374.                     break;  
375.                 }  
376.             }  
377.             if (i == flag) {  
378.                 j++;  
379.             }  
380.         }  
381.   
382.         for (i = 0; i < cityNum; i++) {  
383.             newPopulation[k1][i] = Gh1[i];// 交叉完毕放回种群  
384.             newPopulation[k2][i] = Gh2[i];// 交叉完毕放回种群  
385.         }  
386.   
387.         // System.out.println("进行交叉--------------------------");  
388.         // System.out.println(k1+"交叉后...");  
389.         // for (i = 0; i < cityNum; i++) {  
390.         // System.out.print(newPopulation[k1][i] + "-");  
391.         // }  
392.         // System.out.println();  
393.         // System.out.println(k2+"交叉后...");  
394.         // for (i = 0; i < cityNum; i++) {  
395.         // System.out.print(newPopulation[k2][i] + "-");  
396.         // }  
397.         // System.out.println();  
398.         // System.out.println("交叉完毕--------------------------");  
399.     }  
400.   
401.     // 交叉算子,相同染色体交叉产生不同子代染色体  
402.     public void OXCross1(int k1, int k2) {  
403.         int i, j, k, flag;  
404.         int ran1, ran2, temp;  
405.         int[] Gh1 = new int[cityNum];  
406.         int[] Gh2 = new int[cityNum];  
407.         // Random random = new Random(System.currentTimeMillis());  
408.   
409.         ran1 = random.nextInt(65535) % cityNum;  
410.         ran2 = random.nextInt(65535) % cityNum;  
411.         while (ran1 == ran2) {  
412.             ran2 = random.nextInt(65535) % cityNum;  
413.         }  
414.   
415.         if (ran1 > ran2)// 确保ran1<ran2  
416.         {  
417.             temp = ran1;  
418.             ran1 = ran2;  
419.             ran2 = temp;  
420.         }  
421.   
422.         // 将染色体1中的第三部分移到染色体2的首部  
423.         for (i = 0, j = ran2; j < cityNum; i++, j++) {  
424.             Gh2[i] = newPopulation[k1][j];  
425.         }  
426.   
427.         flag = i;// 染色体2原基因开始位置  
428.   
429.         for (k = 0, j = flag; j < cityNum;)// 染色体长度  
430.         {  
431.             Gh2[j] = newPopulation[k2][k++];  
432.             for (i = 0; i < flag; i++) {  
433.                 if (Gh2[i] == Gh2[j]) {  
434.                     break;  
435.                 }  
436.             }  
437.             if (i == flag) {  
438.                 j++;  
439.             }  
440.         }  
441.   
442.         flag = ran1;  
443.         for (k = 0, j = 0; k < cityNum;)// 染色体长度  
444.         {  
445.             Gh1[j] = newPopulation[k1][k++];  
446.             for (i = 0; i < flag; i++) {  
447.                 if (newPopulation[k2][i] == Gh1[j]) {  
448.                     break;  
449.                 }  
450.             }  
451.             if (i == flag) {  
452.                 j++;  
453.             }  
454.         }  
455.   
456.         flag = cityNum - ran1;  
457.   
458.         for (i = 0, j = flag; j < cityNum; j++, i++) {  
459.             Gh1[j] = newPopulation[k2][i];  
460.         }  
461.   
462.         for (i = 0; i < cityNum; i++) {  
463.             newPopulation[k1][i] = Gh1[i];// 交叉完毕放回种群  
464.             newPopulation[k2][i] = Gh2[i];// 交叉完毕放回种群  
465.         }  
466.     }  
467.   
468.     // 多次对换变异算子  
469.     public void OnCVariation(int k) {  
470.         int ran1, ran2, temp;  
471.         int count;// 对换次数  
472.   
473.         // Random random = new Random(System.currentTimeMillis());  
474.         count = random.nextInt(65535) % cityNum;  
475.   
476.         for (int i = 0; i < count; i++) {  
477.   
478.             ran1 = random.nextInt(65535) % cityNum;  
479.             ran2 = random.nextInt(65535) % cityNum;  
480.             while (ran1 == ran2) {  
481.                 ran2 = random.nextInt(65535) % cityNum;  
482.             }  
483.             temp = newPopulation[k][ran1];  
484.             newPopulation[k][ran1] = newPopulation[k][ran2];  
485.             newPopulation[k][ran2] = temp;  
486.         }  
487.   
488.         /* 
489.          * for(i=0;i<L;i++) { printf("%d ",newGroup[k][i]); } printf("\n"); 
490.          */  
491.     }  
492.   
493.     public void solve() {  
494.         int i;  
495.         int k;  
496.   
497.         // 初始化种群  
498.         initGroup();  
499.         // 计算初始化种群适应度，Fitness[max]  
500.         for (k = 0; k < scale; k++) {  
501.             fitness[k] = evaluate(oldPopulation[k]);  
502.             // System.out.println(fitness[k]);  
503.         }  
504.         // 计算初始化种群中各个个体的累积概率，Pi[max]  
505.         countRate();  
506.         System.out.println("初始种群...");  
507.         for (k = 0; k < scale; k++) {  
508.             for (i = 0; i < cityNum; i++) {  
509.                 System.out.print(oldPopulation[k][i] + ",");  
510.             }  
511.             System.out.println();  
512.             System.out.println("----" + fitness[k] + " " + Pi[k]);  
513.         }  
514.           
515.         for (t = 0; t < MAX_GEN; t++) {  
516.             //evolution1();  
517.             evolution();  
518.             // 将新种群newGroup复制到旧种群oldGroup中，准备下一代进化  
519.             for (k = 0; k < scale; k++) {  
520.                 for (i = 0; i < cityNum; i++) {  
521.                     oldPopulation[k][i] = newPopulation[k][i];  
522.                 }  
523.             }  
524.             // 计算种群适应度  
525.             for (k = 0; k < scale; k++) {  
526.                 fitness[k] = evaluate(oldPopulation[k]);  
527.             }  
528.             // 计算种群中各个个体的累积概率  
529.             countRate();  
530.         }  
531.   
532.         System.out.println("最后种群...");  
533.         for (k = 0; k < scale; k++) {  
534.             for (i = 0; i < cityNum; i++) {  
535.                 System.out.print(oldPopulation[k][i] + ",");  
536.             }  
537.             System.out.println();  
538.             System.out.println("---" + fitness[k] + " " + Pi[k]);  
539.         }  
540.   
541.         System.out.println("最佳长度出现代数：");  
542.         System.out.println(bestT);  
543.         System.out.println("最佳长度");  
544.         System.out.println(bestLength);  
545.         System.out.println("最佳路径：");  
546.         for (i = 0; i < cityNum; i++) {  
547.             System.out.print(bestTour[i] + ",");  
548.         }  
549.   
550.     }  
551.   
552.       
553.     /** 
554.      * @param args 
555.      * @throws IOException 
556.      */  
557.     public static void main(String[] args) throws IOException {  
558.         System.out.println("Start....");  
559.         GA ga = new GA(30, 48, 1000, 0.8f, 0.9f);  
560.         ga.init("c://data.txt");  
561.         ga.solve();  
562.     }  
563.   
564. }  

运行结果截图：

四、总结

看到上面两个结果差别还是相当大的，其实我代码里提供了两个进化函数，两种交叉算子，需要提醒的是上面比较好的结果其实是使用了evolution1()这个进化函数，较差的是使用了evolution()这个函数，他们的最大区别就是前者保留最好染色体不进行交叉变异，后者则是按照基本遗传算法框架的完全交叉变异操作的，其区别之大各位可以深入琢磨，两种交叉算子的区别是一个就是简单的类OX交叉算子，另外一个交叉算子改进了一下，相同染色体交叉产生不同子代染色体，实际上它两对结果影响并不是很大，以上是我的一点点简单的总结，还是那句话，或许你觉得遗传算法效率其实也不怎样，实际上基本的遗传算法是有很多不足的，如容易选入局部收敛，全局搜索能力不够强，但是基本的遗传算法是有很多可以改进的地方，如交叉算子的设计、变异算子的设计、选择策略等等，有关遗传算法个人觉得作为一种智能启发式搜索算法它甚至比别的普通算法（如动态规划）理解起来还容易，而且它特别容易与别的算法相结合，设计新的混合算法，另外在基本遗传算法的基础上还衍生出了很多别的算法，如免疫遗传算法，这些都是一些比较高级的算法。

注：本文部分内容来源于网络，但程序以及分析结果属于本人成果，转载请注明！