嗯哼，第一次写博客，准确说是第一次通过文字的方式记录自己的工作，闲话少叙，技术汪的博客就该直奔技术主题（关于排版问题，会在不断写博客的过程中慢慢学习，先将就着用吧，重在技术嘛~~~）。
遗传算法（Genetic Algorithm, GA），作为很多人接触智能优化算法的第一个算法，互联网上关于遗传算法的资料不可谓不多，但由于其不是本文的重点，故在此不过细展开，只简单说下大概思想：根据现代生物学理论 “物竞天择，适者生存” 原理，不断淘汰适应能力差的个体，模拟生物进化过程。大致步骤为：
- 生成一个初始种群（Initial Population）；
- 通过计算种群中各个个体（Individual）的适应度（Fitness）大小来表示种群中各个个体的对环境的适应能力；
- 根据 “适者生存” 原则选择（Select）部分个体繁衍（即Cross、Mutation操作）生成子代种群；
- 判断是否满足进化结束条件（即算法终止条件）. 若满足，结束进化，输出结果；否则，重复执行步骤2~3.
[注]本文用于求解TSP的遗传算法并非经典遗传算法，而是针对TSP特征写的一个简化版的遗传算法，求解质量比较low，毕竟是第一个java程序，还是要预留些改进空间么不是~~~，下一篇文章将针对本文所用的遗传算法进行改进，给个传送门（Java版GA_TSP （2））。
旅行商问题（Travel Salesman Problem, TSP）作为运筹学分支组合优化中的经典问题，一直备受关注。大白话的说法是：一个旅行商从某一城市出发，希望以最短的路程完成对N个城市的巡回访问，并最终回到出发城市。专业一点的说法是：在有向图中，从某一点开始，以最小代价不重不漏的遍历所有点，并返回初始点。
关于Java必须多说两句。首先，Java语言是新学的，之前一直用的MATLAB，然而实验室的工作站带MATLAB还可以，自己的破笔记本实在带不动。感觉每次用MATLAB运行代码，我的小本都会经历一场生死，从点击“Run” 360小球噌的一下窜上95%那一瞬间，仿佛全世界就是剩下了小本呼哧呼哧的挣扎。
本着人道主义精神，终于在某个深夜卸载了MATLAB，顿时感觉小本的重量都轻了许多（可能是幻觉吧）。MATLAB是卸载了，但毕业还要写代码啊，总不能不毕业吧，所以之后选用Python试了试，相比动辄十几个G的MATLAB，几十M的Python用起来确实不错，在加上Python语言本身确实简单，对代码汪想法的快速程序表达非常友好，以及那句“人生苦短，我用Python”，使得我一度认为Python应该就是我的最终选择了，但是……但是……但是用Python跑了GA&TSP后我就动摇了，运行速度着实堪忧，可能是自己技术太渣，即使使用Pypy也不能达到我的预期，而作为对算法实现效率有着苛刻要求的组合优化问题，为了把其他论文中的求解结果给PK下去，所以……所以……所以我又抛弃了Python。
之所以没有选用高效率的且大一就学过的C语言，则是因为实在搞不定C语言的内存管理，对于指针的使用更是随心而动，致使最后Debug的时候就像二哈咬刺猬，都不知道从哪下口……
嗯哼，然后就是Java了，选择Java就是在使用了排除法后的选择，兼顾了我笔记本的性能缺陷与运行效率。说了这么多，终于到达战场，干货出场：
遗传算法示意图
下面上代码：
Data类：用来放客户点的坐标，也可以用I/O流从外部文件中获取。
1 package GA; 2
3 public class Data { 4 public static double[][] XY(){ 5 double [][] xy = new double [][] { 6 { 1304 , 2312 } , 7 { 3639 , 1315 } , 8 { 4177 , 2244 } , 9 { 3712 , 1399 } , 10 { 3488 , 1535 } , 11 { 3326 , 1556 } , 12 { 3238 , 1229 } , 13 { 4196 , 1004 } , 14 { 4312 , 790 } , 15 { 4386 , 570 } , 16 { 3007 , 1970 } , 17 { 2562 , 1756 } , 18 { 2788 , 1491 } , 19 { 2381 , 1676 } , 20 { 1332 , 695 } , 21 { 3715 , 1678 } , 22 { 3918 , 2179 } , 23 { 4061 , 2370 } , 24 { 3780 , 2212 } , 25 { 3676 , 2578 } , 26 { 4029 , 2838 } , 27 { 4263 , 2931 } , 28 { 3429 , 1908 } , 29 { 3507 , 2367 } , 30 { 3394 , 2643 } , 31 { 3439 , 3201 } , 32 { 2935 , 3240 } , 33 { 3140 , 3550 } , 34 { 2545 , 2357 } , 35 { 2778 , 2826 } , 36 { 2370 , 2975 } 37 }; 38 return xy; 39 } 40 }
DistanceMatrix类：用来计算各客户点间的欧氏距离。原打算也放在GATSP类中，但考虑到有些问题中距离矩阵是给定的，而不是通过公式计算得到的，就单独拿出来了。
1 package GA; 2
3 public class DistanceMatrix { 4 public static double[][] DistMatrix(double[][] xy){ 5 //计算距离矩阵
6 int N = xy.length; 7 double[][] DM = new double[N][N]; 8 for (int i = 0; i < N; i++) { 9 for (int j = 0; j < N; j++) { 10 DM[i][j] = Math.hypot(xy[i][0] - xy[j][0],xy[i][1] - xy[j][1]); 11 } 12 } 13 return DM; 14 } 15 }
Pop类：用来放置对Pop的操作方法，包括计算适应度的fit()函数（貌似这个命名不规范，但是我懒呀，我就不改，你能怎样？？？）和寻找并记录最有个体的Max()函数（写这个函数以及初始化种群的时候非常怀恋MATLAB，MATLAB中自带的的max()能够同时获取最大值的索引，初始化种群就更简单了，一个randperm()解决所有问题。）
1 package GA; 2
3 public class Pop { 4
5 public static double fit(int[] Ind) { 6 //计算适应度函数
7 double[][] xy = Data.XY(); 8 double[][] DM = DistanceMatrix.DistMatrix(xy); 9 double dist = 0.0; 10 int s = Ind.length; 11
12 for (int i0 = 0; i0 < s - 1; i0++) { 13 dist += DM[Ind[i0] - 1][Ind[i0 + 1] - 1]; 14 } 15 dist += DM[Ind[Ind.length - 1] - 1][Ind[0] - 1]; 16 return 1/dist; 17 } 18
19 public static double[] Max(double[] Fit) { 20 //寻找最优个体及相应的位置
21 double[] max = new double[2]; 22 double maxFit = 0.0; 23 double maxIndex = -1; 24 for (int i = 0; i < Fit.length; i++) { 25 if (Fit[i] > maxFit) { 26 maxFit = Fit[i]; 27 maxIndex = (double)i; 28 } 29 } 30 max[0] = maxFit; 31 max[1] = maxIndex; 32 return max; 33 } 34 }
Sharking类：存放扰动算子，想着以后其他智能算法中也能用得着，就一次性造好轮子，以后就能直接用了，写这几个扰动算子的时候也想夸夸MATLAB强大的轮子库, 如fliplr() 就是很好的轮子，还有对数组的各种切割、拼接神奇操作，让我只能一边痛苦的造着轮子，一边默念“效率第一，Java无敌”……
1 package GA; 2
3 import java.util.Random; 4
5 public class Sharking { 6
7 public static int[] Swap(int[] S) { 8 //交换操作
9
10 Random rand = new Random(); 11 int I = rand.nextInt(S.length); 12 int J = rand.nextInt(S.length); 13
14 int tmp = S[I]; 15 S[I] = S[J]; 16 S[J] = tmp; 17
18 return S; 19 } 20
21 public static int[] Flip(int[] S) { 22 //翻转操作
23
24 int[] S0 = new int [S.length]; 25
26 Random rand = new Random(); 27 int tmpI = rand.nextInt(S.length); 28 int tmpJ = tmpI; 29 while(tmpI==tmpJ) { 30 tmpJ = rand.nextInt(S.length); 31 } 32 int I = Math.min(tmpI, tmpJ); 33 int J = Math.max(tmpI, tmpJ); 34
35 for (int i = 0; i < S0.length;i++) { 36 if (i >= I && i <= J) { 37 S0[i] = S[I+J-i]; 38 }else { 39 S0[i] = S[i]; 40 } 41 } 42 return S0; 43 } 44
45 public static int[] Insert(int[] S) { 46 //插入操作
47
48 int[] S0 = new int [S.length]; 49
50 Random rand = new Random(); 51 int tmpI = rand.nextInt(S.length); 52 int tmpJ = tmpI; 53 while(tmpI==tmpJ) { 54 tmpJ = rand.nextInt(S.length); 55 } 56 int I = Math.min(tmpI, tmpJ); 57 int J = Math.max(tmpI, tmpJ); 58
59 for (int i = 0; i < S0.length;i++) { 60 if (i >= I && i < J) { 61 S0[i] = S[i+1]; 62 }else if(i==J){ 63 S0[i] = S[I]; 64 }else{ 65 S0[i] = S[i]; 66 } 67 } 68 return S0; 69 }
72 }
GATSP类：本来准备将算法单独弄一个类，后来……后来……我懒呀、我懒呀…, 所以现在的这个类又臭又长，既包括算法，也包括其他轮子没有干的所有事情，比如说结果输出。
1 package GA; 2
3 import java.util.Random; 4
5 public class GATSP { 6
7 public static double[] Cusume(double[] A) { 8 //适应于轮盘赌的累加器
9 double[] cus = new double[A.length+1]; 10
11 cus[0] = 0.0; 12 for (int i = 0; i < A.length; i++) { 13 cus[i+1] = cus[i] + A[i]; 14 } 15 return cus; 16 } 17
18 public static double Sum(double[] Arr) { 19 //求和
20 double sum = 0.0; 21 for (int i = 0;i <Arr.length;i++) { 22 sum += Arr[i]; 23 } 24 return sum; 25 } 26
27
28
29 public static void main(String[] args) { 30
31 long startTime=System.currentTimeMillis(); 32
33 //参数列表 34 //31城市TSP最优解15377.711
35 int MaxGen = 500; 36 int PopSize =200; 37 double[][] xy = Data.XY(); 38 int N = xy.length; 39
40 double[][] DM = DistanceMatrix.DistMatrix(xy); 41 int[][] Pop = new int[PopSize][N]; 42 double[] Trace = new double[MaxGen]; 43 Pop nowPop = new Pop(); 44 double bs = 1e10; 45 int[] BS = new int[N]; 46
47
48 //生成初始种群
49 for (int p = 0; p < PopSize; p++) { 50 for (int j = 0; j < N;j++) { 51 Pop[p][j] = j + 1; 52 } 53 //随机生成初始个体
54 for (int k = 0; k < N;k++) { 55 Random rand = new Random(); 56 int r = rand.nextInt(N); 57 int tmp; 58 tmp = Pop[p][r]; 59 Pop[p][r] = Pop[p][k]; 60 Pop[p][k] = tmp; 61 } 62 } 63
64 //进入迭代
65 for (int gen = 0; gen < MaxGen;gen++) { 66 // 计算种群适应度
67 double[] Fit = new double[PopSize]; 68 int[] indiv = new int[N]; 69
70 for (int p = 0; p < PopSize;p++) { 71 //取一个个体
72 for (int j = 0; j < N;j++) { 73 indiv[j] = Pop[p][j]; 74 } 75 Fit[p] = nowPop.fit(indiv); 76 } 77
78 //更新最优个体以及最优个体的适应度
79 double[] SortAfterFit = new double[PopSize];//拷贝一份适应度数组
80 for (int i = 0; i < PopSize;i++) { 81 SortAfterFit[i] = Fit[i]; 82 } 83 double[] BestS = nowPop.Max(Fit); 84 double tmpbs = 1/BestS[0]; //当前代最优解（最优个体的适应度）
85 if (tmpbs < bs) { 86 bs = tmpbs; 87 int BestIndex = (int)BestS[1]; 88 for (int i = 0; i < N; i++) { 89 BS[i] =Pop[BestIndex][i]; //最优个体
90 } 91 } 92 Trace[gen] = bs; 93
94 //轮盘赌选择
95 double[] cusFit0 = Cusume(Fit);//数组长度变为N+1，补充了首个元素0.0
96 double sumFit = Sum(Fit); 97 //归一化
98 double[] cusFit = new double[cusFit0.length]; 99 for (int i = 0; i < cusFit.length; i++) { 100 cusFit[i] =cusFit0[i] / sumFit; 101 } 102
103 int[][] newPop = new int[PopSize][N]; 104 for (int q = 0;q < N; q++) { 105 newPop[0][q] = BS[q]; 106 } 107 for (int p = 1; p < PopSize; p++) { 108 double rand = Math.random(); 109 for (int r = 0; r < PopSize; r++) { 110 if (rand > cusFit[r] && rand <= cusFit[r+1]) { 111 for (int q = 0;q < N; q++) { 112 newPop[p][q] = Pop[r][q]; 113 } 114 } 115 } 116 } 117
118 //扰动操作
119 for (int p = 0; p < PopSize; p++) { 120 double R = Math.random(); 121
122 int[] S = new int[N]; 123 for (int i = 0; i < N; i++) { 124 S[i] = newPop[p][i]; 125 } 126
127 int[] S0 = new int[N]; 128 if (R < 0.33) { 129 S0 = Sharking.Swap(S); 130 }else if (R > 0.67) { 131 S0 = Sharking.Insert(S); 132 }else { 133 S0 = Sharking.Flip(S); 134 } 135
136 for (int i = 0; i < N; i++) { 137 newPop[p][i] = S0[i]; 138 } 139 } 140
141 //更新种群
142 for (int p = 0; p < PopSize; p++) { 143 for (int i = 0; i < N; i++) { 144 Pop[p][i] = newPop[p][i]; 145 } 146 } 147 }//结果迭代
148
149 long endTime=System.currentTimeMillis(); 150 //结果输出
151 System.out.println("经过"+MaxGen+"次迭代，最短路径长度为:"+bs); 152 System.out.println("程序用时 "+(double)(endTime - startTime)/1000+"秒."); 153 double bs0 = 15377.711; 154 System.out.println("与最优解的误差为"+(bs-bs0)/bs0*100+"%."); 155 for (int i = 0; i < MaxGen; i++) { 156 System.out.println(i+1+" "+Trace[i]); 157 } 158
159 System.out.println("相应的最短路径为"); 160 for (int i = 0; i < N; i++) { 161 System.out.print(BS[i]+"->"); 162 } 163 System.out.print(BS[0]); 164 } 165 }
本来剧情发展到这里，应该是求解结果展示，然后就可以领盒饭了，无奈结果太渣，不忍心拿出来，所以剧情稍微转下，多说几句关于MATLAB与Java：
本来应该还有一个PlotFigure类，然而Java学的不精，暂时还不会用，说到这里，又怀恋起MATLAB来，其强大的可视化结果能力，确实很有吸引力，想想之前只要用MATLAB写上几行代码就可以在每次跑完程序有一堆酷酷的图出来，比如说算法迭代收敛图、最优路径图什么的，现在只有“28->23->29->19->……”这种结果，心里实在不是很平衡，所以，我决定……下次学习下Java的绘图。
Ps:还是截图纪念下第一次Java写遗传算法~~~
[完]