一、原理

首先明确TSP问题的目标是什么，假设当前有3个城市，需要你从第一个城市开始，遍历所有城市，然后回到初始位置，要求总路径最短。这个时候就需要计算每个城市之间的两两距离，然后按顺序确定一条最短路径。

最稳妥的方案是，使用暴力枚举，列举出来所有的路线为1->2->3->1、1->3->2->1，然后计算一个最短路径即可。

但是当城市数量很多的时候，暴力枚举的方法计算量十分大，此时就需要考虑有没有简单一些的方法，虽然不是十分准确，但是能猜出一个大致的结果，即使不是最优解，只要接近最优结果也能接受。其他大部分智能优化算法都是这种思路，只是使用的具体思路有区别。

模拟退火算法，实际就是猜答案，然后从猜的结果中找个最优的结果输出，当猜的数量够大，结果就最接近实际结果。它会设置一个初始温度比较高例如1000，一个结束温度20，以一定函数从1000降低到20，然后设置一个迭代次数，每次迭代都会随机打乱路线，如果这个路线比之前的路线好，则直接把它作为最优路线，如果没有之前的好，则以一个很小的概率接受，这个概率也是通过随机数确定的，这里为什么要以一个很小的概率接受一个不好的结果呢？其实是为了防止结果陷入局部最优解，但是对于模拟退火这种猜答案的方式，个人感觉其实用不着以很小的概率接受一共不好的路线。

所以这个算法名字听起来不知所云，但是主要就是猜答案，也没有什么特殊的。

二、代码

//模拟退火算法（SA）求解TSP问题
/*类的体会2：
1.类外访问类中private方式：
①通过设置类中的public，get()函数，来获取一些变量值；
②对于数组的获取，一方面可以通过get(下标）函数来完成一对一的获取；
另一方面可以通过在类中public处声明类外的友元函数friend(对象)，友元函数通过对象可以访问到private
2.类中函数要访问类外数据：
①全局变量可以直接访问；
②在类外创建该类的对象，通过对象调用函数，并传递类外数据参数；
③访问其他类还可以用友元函数
*/#include<iostream>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<vector>
#include<algorithm>using namespace std;#define T0 1000				//初始温度
#define T_end 20			//退出温度（环境温度）
#define q 0.9				//退火系数
#define L 10				//每个温度时的迭代次数，即链长
#define C 10				//城市数量//10个城市的坐标：
double citys_position[C][2] =
{{1304,2312},{3639,1315},{4177,2244},{3712,1399},{3488,1535},{3326,1556},{3238,1229},{4196,1004},{4312,7900},{4386,570}
};class Simulated_Annealing
{
private:int i, j;int Current_Solution[C];		//存放一个解int Current_copy[C];			//存放解的副本,用于计算差异double T = T0;					//温度变量,并初始化double f1, f2, df;				//f1是初始解目标值，f2是新解目标值，df是新旧解目标值差int count = 0;					//记录降温次数（因为按系数退火，迭代次数不确定）vector<vector<double>> All_soluitons;	//存放每代中最后的解（也可以是全部解，加上链表迭代的） vector<double> All_fitness;		//存放每代中最后的解值public:/*《函数SA声明》：模拟退火主体功能*/void SA();/*《函数citys_generate声明》：初始化解*/void citys_generate();/*《函数Swap声明》：初始化解*/void Swap(int* input_solution);/*《Fitness函数声明：对传入解计算适应度值》*/double Fitness(int* input_solution);/*《distance函数声明：计算两两节点的距离，传入两个城市各自的坐标信息》*/double distance(double* city1, double* city2);/*《getCount函数：给外部调用count值》*/int getCount() { return count; }/*《getF1函数：给外部调用f1值》*/int getF1() { return f1; }/*《getCurrent_Solution函数：给外部调用该数组》*/int getCurrent_Solution(int k){return Current_Solution[k];}/*《get_All_solutions函数申明：定义为类中的友元函数，可以通过对象去访问类中的private。注意：友元函数是可以访问类中的私有成员，但是得告诉他，他是哪个类的朋友。是通过对象的传参来作过渡，而不能实现直接的访问，他找不到！》*/friend void get_All_solutions(Simulated_Annealing &SA);};void main()
{srand((unsigned)time(NULL));time_t start, finish;			//计时变量start = clock();				//程序运行开始计时/*《调用Simulated_Annealing类》*/Simulated_Annealing SA1;SA1.SA();finish = clock();				//程序结束停止计时//计算运行时间double run_time = ((double)(finish - start)) / CLOCKS_PER_SEC;//输出结果printf("模拟退火算法解TSP问题：\n");cout << "初始温度T0=" << T0 << ",降温系数q=" << q << endl;printf("每个温度迭代%d次,共降温%d次。\n", L, SA1.getCount());/*《调用get_All_solutions函数：输出每次退火的方法和值，友元函数，可以通过对象去访问类中的private》*/get_All_solutions(SA1);printf("最终得TSP问题最优路径为：\n");for (int j = 0; j < C - 1; j++){printf("%d—>", SA1.getCurrent_Solution(j));}printf("%d—>", SA1.getCurrent_Solution(C - 1));printf("%d\n", SA1.getCurrent_Solution(0));cout << "最优路径长度为：" << SA1.getF1() << endl;printf("程序运行耗时%1f秒.\n", run_time);}/*《函数SA定义》：模拟退火主体功能*/
void Simulated_Annealing::SA()
{/*①《调用函数citys_generate》：初始化解*/citys_generate();/*《调用Fitness函数：对传入解计算适应度值》*/f1 = Fitness(Current_Solution);//随机求解的一个代价值while (T > T_end)//当温度低于结束温度时，退火结束{All_soluitons.push_back({});	//每代开始添加一个空行，存放本代结果值All_fitness.push_back({});		//每代开始添加一个空行，存放本代代价值for (i = 0; i < L; i++)//迭代次数5{//②复制初始解for (j = 0; j < C; j++){Current_copy[j] = Current_Solution[j];}/*③《调用Swap函数：对传入解做邻域搜索，两点交换》*/Swap(Current_copy);//随机生成一个新的路线/*④《调用Fitness函数：对传入解计算适应度值》*/f2 = Fitness(Current_copy);//计算当前代价df = f1 - f2;//当前代价和前一个代价差/*退火原理：Metropolis准则,df<0*///⑤若新解>旧解值,df<0，则以概率 exp(df / T) 接受新解  df越大，指数越大。含义为新解效果越差，接受概率越小if (df < 0){//随机数（0，1），用于决定是否接受新解double r;r = (double)rand() / RAND_MAX; //分母32767if (r < exp(df / T))//以很小的概率接受这个不好的解{//接受新解for (j = 0; j < C; j++){Current_Solution[j] = Current_copy[j];}f1 = f2;}}//⑥若新解<=旧解值,df>=0，则直接接受新解else//如果新解效果比较好，直接用这个新解{for (j = 0; j < C; j++){Current_Solution[j] = Current_copy[j];}f1 = f2;}}//⑦存放本次迭代的最后方案和适应值for (int j = 0; j < C; j++){All_soluitons[count].push_back(Current_Solution[j]);//每次迭代的路径存入vector}All_fitness[count] = f1;//⑧以一定的速率降温T *= q;//以1/2的速率减小count++;}}
/*《函数citys_generate定义》：初始化解*/
void Simulated_Annealing::citys_generate()
{//①一个城市序列vector<int> temp_city;for (int i = 0; i < C; i++)//城市数量{temp_city.push_back(i + 1);}//②打乱random_shuffle(temp_city.begin(), temp_city.end());//均匀分布来随机移动元素//③赋值给Current_Solutionfor (int j = 0; j < temp_city.size(); j++){Current_Solution[j] = temp_city[j];//初始为随机解}
}
/*《函数Swap定义》：初始化解*/
void Simulated_Annealing::Swap(int* input_solution)
{//①生成交换节点下标int point1 = rand() % C;//交换点1int point2 = rand() % C;//交换点2while (point1 == point2){point2 = rand() % C;//保证交换点不同}//②交换swap(input_solution[point1], input_solution[point2]);//随机交换最终路径的航点
}/*《Fitness函数定义：对传入解计算适应度值》*/
double Simulated_Annealing::Fitness(int* input_solution)//代价函数
{//初始化路径长度double cost = 0;//从第一个城市遍历到最后一个城市for (int j = 0; j < C - 1; j++){/*《调用distance函数：计算两两节点的距离，传入两个城市各自的坐标信息》*/int k = input_solution[j];//城市序号-1=城市位置下标   第二个参数为第二个城市的位置cost += distance(citys_position[input_solution[j] - 1], citys_position[input_solution[j + 1] - 1]);//初始位置为第一个城市}//从最后一个城市回到第一个城市cost += distance(citys_position[input_solution[C - 1] - 1], citys_position[input_solution[0] - 1]);return cost;
}
/*《distance函数声明：计算两两节点的距离，传入两个城市各自的坐标信息》*/
double Simulated_Annealing::distance(double* city1, double* city2)
{/*计算相邻两城市间距离*/double x1 = city1[0];			//城市1横坐标double y1 = city1[1];double x2 = city2[0];double y2 = city2[1];			//城市2纵坐标double dist = pow((pow((x1 - x2), 2) + pow((y1 - y2), 2)), 0.5);return dist;					//返回距离值
}
/*《get_All_solutions函数申明：定义为类中的友元函数，通过对象可以访问类中的向量》*/
void get_All_solutions(Simulated_Annealing &SA)
{cout << "每次退火内部迭代的最终解：" << endl;for (int i = 0; i < SA.All_soluitons.size(); i++){for (int j = 0; j < SA.All_soluitons[i].size(); j++){cout << SA.All_soluitons[i][j] << "—>";}cout << SA.All_soluitons[i][0] << endl;cout << "路线代价为：" << SA.All_fitness[i] << std::endl << std::endl;}
}