0
0

java实现遗传算法求解最短路径问题

  1.     遗传算法（Genetic Algorithm，GA）最早是由美国的John holland于20世纪70年代提出,该算法是根据大自然中生物体进化规律而设计提出的。是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型，是一种通过模拟自然进化过程搜索最优解的方法。

1、问题描述：

  1.     图1所示为一个最短路径问题，每条边代表一条可以通行的弧，边上的数值表示这条弧的长度，多条弧相互连接形成路径，目标是寻找一条从节点0出发到节点5的最短路径。

a0cb89d8537b4c1ba31d60e63be2bcf8.jpeg

2、编码

  1.     从表现型到基因型的映射称为编码。图1中每条路径的每个节点对应一个基因，通过对节点的有序组合可以将每条路径映射为一个向量。每个向量长度为6，起始和结束位置的数值分别为0和5，代表从节点0出发，到节点5终止，图1中节点间边的长度代表节点间的距离，若两节点间无边相连，则这两个节点间的距离为一个极大的数M。由于向量长度固定为6，而解中可能并不包含所有的节点，个体中可能会存在多个相邻且重复出现的节点，因此设置节点到其本身的距离为0。

3、个体类

  1.     每个个体包含路径Path和适应度length（即路径长度）两个属性，每个个体路径属性中的起点为0，结束点为5，其余位置数值随机生成（0-5范围内的整数），向量长度固定为6。个体类中定义的compareTo方法是为了用于在选择算子中采用迭代器进行个体的删除。
  1. public class Individual implements Comparable<Individual>{
  2.     int[] Path = new int[6];    //存储路径
  3.     int length;                  //表示适应度
  5.     public int[] getPath() {
  6.         return Path;
  7.     }
  9.     public void setPath(int[] path) {
  10.         Path = path;
  11.     }
  13.     public int getLength() {
  14.         return length;
  15.     }
  17.     public void setLength(int length) {
  18.         this.length = length;
  19.     }
  21.     public int compareTo(Individual o) {
  22.         if(this.getLength() > o.getLength())
  23.         {
  24.             return -1;
  25.         }
  26.         else if(this.getLength()<o.getLength())
  27.         {
  28.             return 1;
  29.         }
  30.         else
  31.         {
  32.             return 0;
  33.         }
  34.     }
  36. }

4、遗传算法解决最短路径问题主方法

  1.     主方法包括（1）数据的初始化（2）定义初始种群（3）循环依次调用选择、交叉和变异算子（4）输出迭代后的结果。以邻接矩阵的形式表达图1中各节点间的距离，  建立一个集合表示种群，随机产生10个个体并添加到初始种群完成种群的初始化，设置迭代次数并依次调用三个算子更新种群，最终输出结果。详细代码如下：
  1.     static int[][] matrix = new int[6][6];
  2.     final static int M = 10000;
  3.     static Random rand = new Random();
  4.     public static void main(String[] args) {
  5.         //邻接矩阵
  6.         matrix[0] = new int[]{0, 6, 3, M, M, M};/*1*/
  7.         matrix[1] = new int[]{6, 0, 2, 5, M, M};/*2*/
  8.         matrix[2] = new int[]{3, 2, 0, 3, 4, M};/*3*/
  9.         matrix[3] = new int[]{M, 5, 3, 0, 2, 3};/*4*/
  10.         matrix[4] = new int[]{M, M, 4, 2, 0, 5};/*5*/
  11.         matrix[5] = new int[]{M, M, M, 3, 5, 0};/*6*/
  13.         //定义初始种群
  14.         Math.random();
  15.         List<Individual> Population = new ArrayList<>();
  16.         for (int i = 0; i < 10; i++) {
  17.             //随机生成十个个体添加到初始种群列表
  18.             Individual Popu = new Individual();
  19.             Popu.Path[0] = 0;
  20.             Popu.Path[1] = rand.nextInt(5);
  21.             Popu.Path[2] = rand.nextInt(5);
  22.             Popu.Path[3] = rand.nextInt(5);
  23.             Popu.Path[4] = rand.nextInt(5);
  24.             Popu.Path[5] = 5;
  25.             Popu.length = M;
  26.             Population.add(Popu);
  27.         }
  29.         for(int i = 0; i<2000; i++){
  30.             System.out.println("第"+(i+1)+"次迭代开始！");
  31.             //初始种群中选择出5个较优的个体
  32.             List<Individual> NewSelPopu = Selection(Population);
  33.             //交叉
  34.             List<Individual> NewCroPopu = Crossover(NewSelPopu);
  35.             //变异
  36.             Population = Variation(NewCroPopu);
  37.             System.out.println("第"+ (i+1) + "次迭代完成！");
  38.         }
  40.         //输出迭代后的种群
  41.         System.out.print("2000次迭代后集合中个体的长度：");
  42.         for(Individual a : Population){
  43.             System.out.print(a.length +" ");
  44.         }
  45.         //对集合中的个体排序
  46.         Collections.sort(Population);
  47.         //输出排序后的集合中个体的长度
  48.         System.out.print("\n" +"2000次迭代后所有个体的最短路径长度为:" + Population.get(9).length);
  49.         System.out.println("\n"+"最短路径为：" + Arrays.toString(Population.get(9).Path));
  50.     }

5、适应度

  1. 该问题中适应度即为每个个体所代表的路径长度，适应度函数如下：
  1. static void Fitness(Individual in){
  2.         //计算路径长度
  3.         in.length = matrix[in.Path[0]][in.Path[1]] + matrix[in.Path[1]][in.Path[2]] +
  4.                 matrix[in.Path[2]][in.Path[3]] + matrix[in.Path[3]][in.Path[4]] + matrix[in.Path[4]][in.Path[5]];
  5.     }

6、选择算子

  1. 输入：包含10个个体的种群。
  3. 输出：包含5个个体的种群。
  5. 计算所输入的种群的所有个体的适应度，并按照适应度将这些个体进行升序排列，删除掉其中适应度较大的五个个体，并返回剩余的种群。代码如下：
  1. static List<Individual> Selection(List<Individual> Population){
  2.         System.out.print("排序前集合中个体的长度：");
  3.         for(Individual a : Population){
  4.             System.out.print(a.length +" ");
  5.         }
  6.         //对集合中的个体排序
  7.         Collections.sort(Population);
  8.         //输出排序后的集合中个体的长度
  9.         System.out.print("\n" +"排序后集合中个体的长度:");
  10.         for(Individual a : Population){
  11.             System.out.print(a.length +" ");
  12.         }
  14.         //使用迭代器删除个体
  15.         Iterator<Individual> iterator = Population.iterator();
  16.         while(iterator.hasNext() && Population.size()>5){
  17.             Individual next = iterator.next();
  18.             if(next != null)
  19.                 iterator.remove();
  20.         }
  21.         //输出删除后的个体的长度
  22.         System.out.print("\n" + "选择后的个体的长度：");
  23.         for(Individual a : Population){
  24.             System.out.print(a.length +" ");
  25.         }
  26.         System.out.println("\n" + "选择完成!");
  27.         return Population;
  28.     }

7、交叉算子

  1. 输入：包含5个个体的种群。
  3. 输出：包含7个个体的种群。
  5. 在经过选择算子后生成的包含5个个体的种群中随机选择两个不同的个体，选择一个不是首也不是尾的基因，将所选择的两个个体对应的基因进行交叉，并将新产生的个体添加到种群中去，返回新的种群。代码如下：
  1. static List<Individual> Crossover(List<Individual> NewSelPopu){
  2.         //复制集合
  3.         List<Individual> CroPopu = new ArrayList<>();
  4.         for (int i = 0; i < 5; i++) {
  5.             Individual ind = new Individual();
  6.             System.arraycopy(NewSelPopu.get(i).Path, 0, ind.Path, 0, 6);
  7.             ind.length = NewSelPopu.get(i).length;
  8.             CroPopu.add(ind);
  9.         }
  10.         //随机选择两个不同的个体
  11.         int i = rand.nextInt(5);
  12.         int j = rand.nextInt(5);
  13.         while(i == j){
  14.             j = rand.nextInt(5);
  15.         }
  16.         //随机选择一个不是首尾的基因进行交叉
  17.         int k = rand.nextInt(4) + 1;
  19.         int l = CroPopu.get(i).Path[k];
  20.         CroPopu.get(i).Path[k] = CroPopu.get(j).Path[k];
  21.         CroPopu.get(j).Path[k] = l;
  23.         //更新length并添加到集合中
  24.         Fitness(CroPopu.get(i));
  25.         Fitness(CroPopu.get(j));
  26.         NewSelPopu.add(CroPopu.get(i));
  27.         NewSelPopu.add(CroPopu.get(j));
  29.         //输出交叉产生的个体
  30.         System.out.println("交叉产生的个体为：" + Arrays.toString(CroPopu.get(i).Path) + "和" + Arrays.toString(CroPopu.get(j).Path));
  32.         //输出交叉后的个体适应度
  33.         System.out.print("交叉后的个体的长度：");
  34.         for(Individual a : NewSelPopu){
  35.             System.out.print(a.length +" ");
  36.         }
  37.         System.out.println("\n"+"交叉完成！");
  38.         return NewSelPopu;
  39.     }

8、变异算子

  1. 输入：包含7个个体的种群。
  3. 输出：包含10个个体的种群。
  5. 随机选择一个个体，将这个个体的随机一个不为首或尾的基因进行变异，随机产生一个[0,5]中的数值代替该基因处的数值，将变异后产生的新的个体添加到种群中。重复以上步骤三次，共计产生三个新的个体。这里需要注意的是，由于每次选择要变异的个体都是随机的，可能存在两次甚至三次选择同一个个体进行变异的情况，这也符合自然界中生物遗传的思想。代码如下：
  1. static List<Individual> Variation(List<Individual> NewCroPopu){
  2.         //复制集合
  3.         List<Individual> VarPopu = new ArrayList<>();
  4.         for (int i = 0; i < 7; i++) {
  5.             Individual ind = new Individual();
  6.             System.arraycopy(NewCroPopu.get(i).Path, 0, ind.Path, 0, 6);
  7.             ind.length = NewCroPopu.get(i).length;
  8.             VarPopu.add(ind);
  9.         }
  11.         //变异三次
  12.         for (int i = 0; i < 3; i++) {
  13.             //随机选择一个个体的一个基因进行变异
  14.             int j = rand.nextInt(7);
  15.             VarPopu.get(j).Path[(rand.nextInt(4) + 1)] = rand.nextInt(5);
  16.             //更新length并添加到集合中
  17.             Fitness(VarPopu.get(j));
  18.             NewCroPopu.add(VarPopu.get(j));
  19.             //输出交叉产生的个体
  20.             System.out.println("第"+ (i+1) +"次变异产生的个体为：" + Arrays.toString(VarPopu.get(i).Path));
  21.         }
  23.         //输出变异后的个体适应度
  24.         System.out.print("变异后的个体的长度：");
  25.         for(Individual a : NewCroPopu){
  26.             System.out.print(a.length +" ");
  27.         }
  28.         System.out.println("\n"+"变异完成！");
  29.         return NewCroPopu;
  30.     }

9、总结

  1.     本文解决的问题复杂度较低，适合代码或者遗传算法的初学者尝试解决。另外在解决该问题时，本文所采用的编码方式较为简单，虽可以很好的解决此类简单问题，但在求解更复杂的问题时可能会存在计算结果为不可行解的情况，因此在采用遗传算法解决更复杂的问题时，非常有必要对编码方式进行进一步的加工，使其更适合问题特性且计算结果更优。完整的代码如下：
  1. import java.util.*;
  3. public class GeneticAlgorithm {
  4.     static int[][] matrix = new int[6][6];
  5.     final static int M = 10000;
  6.     static Random rand = new Random();
  7.     public static void main(String[] args) {
  8.         //邻接矩阵
  9.         matrix[0] = new int[]{0, 6, 3, M, M, M};/*1*/
  10.         matrix[1] = new int[]{6, 0, 2, 5, M, M};/*2*/
  11.         matrix[2] = new int[]{3, 2, 0, 3, 4, M};/*3*/
  12.         matrix[3] = new int[]{M, 5, 3, 0, 2, 3};/*4*/
  13.         matrix[4] = new int[]{M, M, 4, 2, 0, 5};/*5*/
  14.         matrix[5] = new int[]{M, M, M, 3, 5, 0};/*6*/
  16.         //定义初始种群
  17.         Math.random();
  18.         List<Individual> Population = new ArrayList<>();
  19.         for (int i = 0; i < 10; i++) {
  20.             //随机生成十个个体添加到初始种群列表
  21.             Individual Popu = new Individual();
  22.             Popu.Path[0] = 0;
  23.             Popu.Path[1] = rand.nextInt(5);
  24.             Popu.Path[2] = rand.nextInt(5);
  25.             Popu.Path[3] = rand.nextInt(5);
  26.             Popu.Path[4] = rand.nextInt(5);
  27.             Popu.Path[5] = 5;
  28.             Popu.length = M;
  29.             Population.add(Popu);
  30.         }
  31.         //输出初始种群
  32.         for (int i = 0; i < 10; i++) {
  33.             System.out.println("初始种群中第" + (i+1) + "个个体为：");
  34.             for (int j = 0; j < 6; j++) {
  35.                 System.out.print(Population.get(i).Path[j]);
  36.             }
  37.             //更新length
  38.             for (int j = 0; j < 10; j++) {
  39.                 Fitness(Population.get(j));
  40.             }
  41.             System.out.println("\n" +"适应度为：" +Population.get(i).length);
  42.             System.out.println();
  43.         }
  45.         for(int i = 0; i<2000; i++){
  46.             System.out.println("第"+(i+1)+"次迭代开始！");
  47.             //初始种群中选择出5个较优的个体
  48.             List<Individual> NewSelPopu = Selection(Population);
  49.             //交叉
  50.             List<Individual> NewCroPopu = Crossover(NewSelPopu);
  51.             //变异
  52.             Population = Variation(NewCroPopu);
  53.             System.out.println("第"+ (i+1) + "次迭代完成！");
  54.         }
  56.         //输出迭代后的种群
  57.         System.out.print("2000次迭代后集合中个体的长度：");
  58.         for(Individual a : Population){
  59.             System.out.print(a.length +" ");
  60.         }
  61.         //对集合中的个体排序
  62.         Collections.sort(Population);
  63.         //输出排序后的集合中个体的长度
  64.         System.out.print("\n" +"2000次迭代后所有个体的最短路径长度为:" + Population.get(9).length);
  65.         System.out.println("\n"+"最短路径为：" + Arrays.toString(Population.get(9).Path));
  66.     }
  68.     //选择函数,删除种群中较大的5个个体，返回两个所选的适应度最好的个体
  69.     //输入：10个个体的种群
  70.     //输出：5个个体的种群
  71.     static List<Individual> Selection(List<Individual> Population){
  72.         System.out.print("排序前集合中个体的长度：");
  73.         for(Individual a : Population){
  74.             System.out.print(a.length +" ");
  75.         }
  76.         //对集合中的个体排序
  77.         Collections.sort(Population);
  78.         //输出排序后的集合中个体的长度
  79.         System.out.print("\n" +"排序后集合中个体的长度:");
  80.         for(Individual a : Population){
  81.             System.out.print(a.length +" ");
  82.         }
  84.         //使用迭代器删除个体
  85.         Iterator<Individual> iterator = Population.iterator();
  86.         while(iterator.hasNext() && Population.size()>5){
  87.             Individual next = iterator.next();
  88.             if(next != null)
  89.                 iterator.remove();
  90.         }
  91.         //输出删除后的个体的长度
  92.         System.out.print("\n" + "选择后的个体的长度：");
  93.         for(Individual a : Population){
  94.             System.out.print(a.length +" ");
  95.         }
  96.         System.out.println("\n" + "选择完成!");
  97.         return Population;
  98.     }
  100.     //交叉产生两个新的个体
  101.     //输入：5个个体的种群
  102.     //输出：7个个体的种群
  103.     static List<Individual> Crossover(List<Individual> NewSelPopu){
  104.         //复制集合
  105.         List<Individual> CroPopu = new ArrayList<>();
  106.         for (int i = 0; i < 5; i++) {
  107.             Individual ind = new Individual();
  108.             System.arraycopy(NewSelPopu.get(i).Path, 0, ind.Path, 0, 6);
  109.             ind.length = NewSelPopu.get(i).length;
  110.             CroPopu.add(ind);
  111.         }
  112.         //随机选择两个不同的个体
  113.         int i = rand.nextInt(5);
  114.         int j = rand.nextInt(5);
  115.         while(i == j){
  116.             j = rand.nextInt(5);
  117.         }
  118.         //随机选择一个不是首尾的基因进行交叉
  119.         int k = rand.nextInt(4) + 1;
  121.         int l = CroPopu.get(i).Path[k];
  122.         CroPopu.get(i).Path[k] = CroPopu.get(j).Path[k];
  123.         CroPopu.get(j).Path[k] = l;
  125.         //更新length并添加到集合中
  126.         Fitness(CroPopu.get(i));
  127.         Fitness(CroPopu.get(j));
  128.         NewSelPopu.add(CroPopu.get(i));
  129.         NewSelPopu.add(CroPopu.get(j));
  131.         //输出交叉产生的个体
  132.         System.out.println("交叉产生的个体为：" + Arrays.toString(CroPopu.get(i).Path) + "和" + Arrays.toString(CroPopu.get(j).Path));
  134.         //输出交叉后的个体适应度
  135.         System.out.print("交叉后的个体的长度：");
  136.         for(Individual a : NewSelPopu){
  137.             System.out.print(a.length +" ");
  138.         }
  139.         System.out.println("\n"+"交叉完成！");
  140.         return NewSelPopu;
  141.     }
  143.     //变异两个个体
  144.     //输入：7个个体的种群
  145.     //输出：10个个体的种群
  146.     static List<Individual> Variation(List<Individual> NewCroPopu){
  147.         //复制集合
  148.         List<Individual> VarPopu = new ArrayList<>();
  149.         for (int i = 0; i < 7; i++) {
  150.             Individual ind = new Individual();
  151.             System.arraycopy(NewCroPopu.get(i).Path, 0, ind.Path, 0, 6);
  152.             ind.length = NewCroPopu.get(i).length;
  153.             VarPopu.add(ind);
  154.         }
  156.         //变异三次
  157.         for (int i = 0; i < 3; i++) {
  158.             //随机选择一个个体的一个基因进行变异
  159.             int j = rand.nextInt(7);
  160.             VarPopu.get(j).Path[(rand.nextInt(4) + 1)] = rand.nextInt(5);
  161.             //更新length并添加到集合中
  162.             Fitness(VarPopu.get(j));
  163.             NewCroPopu.add(VarPopu.get(j));
  164.             //输出交叉产生的个体
  165.             System.out.println("第"+ (i+1) +"次变异产生的个体为：" + Arrays.toString(VarPopu.get(i).Path));
  166.         }
  168.         //输出变异后的个体适应度
  169.         System.out.print("变异后的个体的长度：");
  170.         for(Individual a : NewCroPopu){
  171.             System.out.print(a.length +" ");
  172.         }
  173.         System.out.println("\n"+"变异完成！");
  174.         return NewCroPopu;
  175.     }
  177.     //更新适应度
  178.     static void Fitness(Individual in){
  179.         //计算路径长度
  180.         in.length = matrix[in.Path[0]][in.Path[1]] + matrix[in.Path[1]][in.Path[2]] +
  181.                 matrix[in.Path[2]][in.Path[3]] + matrix[in.Path[3]][in.Path[4]] + matrix[in.Path[4]][in.Path[5]];
  182.     }
  184. }
  1. public class Individual implements Comparable<Individual>{
  2.     int[] Path = new int[6];    //存储路径
  3.     int length;                  //表示适应度
  5.     public int[] getPath() {
  6.         return Path;
  7.     }
  9.     public void setPath(int[] path) {
  10.         Path = path;
  11.     }
  13.     public int getLength() {
  14.         return length;
  15.     }
  17.     public void setLength(int length) {
  18.         this.length = length;
  19.     }
  21.     public int compareTo(Individual o) {
  22.         if(this.getLength() > o.getLength())
  23.         {
  24.             return -1;
  25.         }
  26.         else if(this.getLength()<o.getLength())
  27.         {
  28.             return 1;
  29.         }
  30.         else
  31.         {
  32.             return 0;
  33.         }
  34.     }
  36. }
  1.     运行结果如下：
  1. 第2000次迭代完成！
  2. 2000次迭代后集合中个体的长度：9 9 9 9 9 9 9 9 9 10003 
  3. 2000次迭代后所有个体的最短路径长度为:9
  4. 最短路径为：[0, 2, 2, 2, 3, 5]
  1.     由于问题比较简单，一般迭代100次左右就已经求得最优解，为保证结果的最优性，本文对进行了2000次迭代，迭代结果与上一篇文章中通过Dijkstra方法求得的最优解一致。
  3.     在进行代码的编写时也遇到了一些比较经典的问题，总结如下：
  5.     1.初始版本的选择算子中，先将每个个体的适应度属性存储到一个新建的数组中进行排序，此方法舍近求远，因此对其进行改进，采用Collections.sort（）对种群中的个体进行排序。
  7.     2.初始版本的选择算子中，采用for循环和while循环的方式删除适应度大的个体，此种方式导致程序运行时出现死循环且不能很好的实现删除5个适应度大的个体的目的，for循环中每次删除个体后种群数量发生变化，程序运行会出现异常，因此对其进行改进，采用迭代器对个体进行删除。
  9.     3.在交叉和变异算子中需要对集合进行复制，由于集合名代表的是集合存储的地址，直接赋值仍然会修改原集合中的数据，因此在对集合进行深层次的复制，新建个体并将原集合中的个体属性值分别赋给新个体后添加到复制集合中去。
  11.     本文适合于代码或者遗传算法的初学者阅读，也欢迎各位经验丰富的博主提出宝贵的意见！
标签： java 启发式算法 算法
本文转载自: https://blog.csdn.net/Xing_LG/article/details/125128518
版权归原作者 Xing_LG 所有， 如有侵权，请联系我们删除。
登录后发布评论

“java实现遗传算法求解最短路径问题”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？