爬山算法 | Java版HA_TSP

　　嗯哼，今天记录下采用Java编写的爬山算法(Hill Algorithm)求解TSP问题。

　　爬山算法与其他智能算法类似，是一种用来求解多峰函数最值的算法，爬山算法的基本思想是新解不劣于当前解则转移，否则不转移。通俗的解说是兔子爬山的例子，其他博客上介绍的十分细致，在此不再赘述。

　　爬山算法的算法描述为：

• • Step1：初始化。通过某种方法产生初始解S0，令当前解S = S0，全局最优解的值bs = inf，全局最优解BS = S0，当前迭代次数count = 0，最大迭代次数为MaxCount；
  • Step2：评价当前解。通过评价函数 Eval() 对当前解S进行评价；
  • Step3：更新最优解。如果 Eval(S) 优于（或不劣于） bs，则令全局最优解BS = S，全局最优解的值bs = Eval(BS)；
  • Step3：更新当前解。令当前解S = BS，迭代次数count++；
  • Step4：终止条件判定。如果count < MaxCount, 转至Step2，否者终止程序，输出结果。

　　下面上干货：

 package Hill_Algorithm;

 import java.util.Random;

 /**
  * @file_name SATSP.java
  * @author Alex Xu
  * @date 2018/8/11
  * @detail Simulated Annealing to solve Travel Salesman Problem
  */

 public class HATSP {

     public static double[] HA() {

         //参数列表
         int MaxCount = 10000;

         //初始化
         double[][] xy = Data.XY();
         int N = xy.length;

         double bs ;
         double Nowbs;
         int[] BS = new int[N];
         int[] S = new int[N];

         //生成随机初始解
         for (int i = 0; i < N; i++) {
             S[i] = i + 1;
         }
         for (int k = 0; k < N;k++) {
             Random rand = new Random();
             int r = rand.nextInt(N);
             int tmp;
             tmp = S[r];
             S[r] = S[k];
             S[k] = tmp;
         }
         bs = Evaluate.Eval(S);

         //进入迭代过程
         int effI = 0;
         for (int count = 0; count < MaxCount; count++) {

             //产生一个新解
             int[] newS = new int[N];
             double R = Math.random();

             if (R < 0.33) {
                 newS = Sharking.Swap(S);
             }else if (R > 0.67) {
                 newS = Sharking.Insert(S);
             }else {
                 newS = Sharking.Flip(S);
             }
             Nowbs = Evaluate.Eval(newS);            

             //解的更新
             if (Nowbs < bs) {
                 bs = Nowbs;
                 effI++;
                 System.out.println( "第  " + effI + "次有效迭代出现在第  " + count + "次迭代，对应的解为  " + bs);
                 System.arraycopy(newS, 0, BS, 0, N);
             }
             System.arraycopy(BS, 0, S, 0, N);
         }

         //结果输出
         double[] Solution = new double[N + 2];
         Solution[0] = bs;
         Solution[1] = MaxCount;

         for (int i = 2; i < N+2; i++) {
             Solution[i] = BS[i-2];
         }
         return Solution;
     }
 }

　　求解31个城市的TSP，求解结果如下，程序总迭代次数为10000次，有效迭代次数为89次，最后一次有效迭代出现在第3637次。与目前已知最优解误差0.16%。