[数据结构与算法]退火算法解决TSP问题，python描述

import numpy as np
import matplotlib.pyplot as plt
import math

# 子程序：计算各城市间的距离，得到距离矩阵
def getdistMat(coordinates):
    num = coordinates.shape[0]  # 坐标点
    distmat = np.zeros((num, num))  # 距离矩阵
    for i in range(num):
        for j in range(i, num):
        	if i==j:
        		distmat[i][j] =10000
        	else:
            	distmat[i][j] = distmat[j][i] = np.linalg.norm(coordinates[i] - coordinates[j])
    return distmat

# 子程序：初始化模拟退火算法的控制参数
def initPara():
    tInitial = 1000.0  # 设定初始退火温度(initial temperature)
    tFinal = 1.0  # 设定终止退火温度(stop temperature)
    nMarkov = 1000  # Markov链长度，也即内循环运行次数
    alpha = 0.99  # 设定降温参数，T(k)=alpha*T(k-1)
    return tInitial, tFinal, alpha, nMarkov


def drawtour(tourGiven, value, coordinates,nameCity):
    fig = plt.figure()
    num = len(tourGiven)
    plt.title("Optimization result of TSP{:d}".format(num))
    plt.rcParams['font.sans-serif'] = [u'SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    x0, y0 = coordinates[tourGiven[num - 1]]
    x1, y1 = coordinates[tourGiven[0]]
    plt.scatter(int(x0), int(y0), s=15, c='g')  # 绘制城市坐标点 C(n-1)
    plt.plot([x1, x0], [y1, y0], c='r')  # 绘制旅行路径 C(n-1)~C(0)
    for i in range(num - 1):
        x0, y0 = coordinates[tourGiven[i]]
        x1, y1 = coordinates[tourGiven[i + 1]]
        plt.text(int(x0), int(y0),nameCity[tourGiven[i]], ha='center', va='bottom', fontsize=10.5)
        plt.scatter(int(x0), int(y0), s=15, c='r')  # 绘制城市坐标点 C(i)
        plt.plot([x1, x0], [y1, y0], c='b')  # 绘制旅行路径 C(i)~C(i+1)
    plt.xlabel("Total mileage of the tour:{:.1f}".format(value))  # 设置 x轴标注
    plt.show()


# 距离迭代图
def drawiter(recordNow, recordBest, recordNew):
    fig = plt.figure()
    plt.title("Distance iteration graph")  # 设置图形标题
    plt.plot(np.array(recordNow), 'g-', label='Now')  # 绘制 valueNow曲线
    plt.plot(np.array(recordNew), 'b-', label='New')  # 绘制 valuenew曲线
    plt.plot(np.array(recordBest), 'r-', label='Best')  # 绘制 valueBest曲线
    plt.xlabel("Number of iterations")  # 设置 x轴标注
    plt.ylabel("Distance value")  # 设置 y轴标注
    plt.legend()  # 显示图例
    plt.show()


# 子程序：计算 TSP 路径长度
def calTourMileage(tourGiven, nCity, distMat):
    tourMileage = 0
    for i in range(nCity - 1):  # dist(0,1),...dist((n-2)(n-1))
        tourMileage += distMat[tourGiven[i], tourGiven[i + 1]]
    tourMileage += distMat[tourGiven[nCity - 1], tourGiven[0]]  # dist((n-1),0)
    return round(tourMileage)


def greedy(distMat, start_index):
    sum_distance, seq_result, n = 0, [start_index, ], len(distMat)
    for path_index in range(n - 1):
        distance_list = distMat[start_index]
        min_dis = max(distance_list)
        for index, distance in enumerate(distance_list):
            if (index not in seq_result) and (distance < min_dis):
                min_dis = distance
                start_index = index
        sum_distance += min_dis
        seq_result.append(start_index)
    return sum_distance, seq_result


def mutateSwap(tourGiven, nCity):
    if np.random.rand() > 0.5:  # 交换路径中的这2个节点的顺序，np.random.rand()产生[0, 1)区间的均匀随机数
        while True:  # 产生两个不同的随机数
            loc1 = np.int(np.ceil(np.random.rand() * (nCity - 1)))  # np.ceil表示向大于等于该值的向上取整；np.floor:向下取整
            loc2 = np.int(np.ceil(np.random.rand() * (nCity - 1)))
            if loc1 != loc2:
                break
        tourGiven[loc1], tourGiven[loc2] = tourGiven[loc2], tourGiven[loc1]
    else:  # 三交换
        while True:
            loc1 = np.int(np.ceil(np.random.rand() * (nCity - 1)))
            loc2 = np.int(np.ceil(np.random.rand() * (nCity - 1)))
            loc3 = np.int(np.ceil(np.random.rand() * (nCity - 1)))
            if ((loc1 != loc2) & (loc2 != loc3) & (loc1 != loc3)):
                break
            # 下面的三个判断语句使得loc1<loc2<loc3
        if loc1 > loc2:
            loc1, loc2 = loc2, loc1
        if loc2 > loc3:
            loc2, loc3 = loc3, loc2
        if loc1 > loc2:
            loc1, loc2 = loc2, loc1
            # 下面的三行代码将[loc1,loc2)区间的数据插入到loc3之后
        tourTmp = tourGiven[loc1:loc2].copy()
        tourGiven[loc1:loc3 - loc2 + 1 + loc1] = tourGiven[loc2:loc3 + 1].copy()
        tourGiven[loc3 - loc2 + 1 + loc1:loc3 + 1] = tourTmp.copy()  # 通过 交换操作 产生新路径
    return tourGiven


# 主程序


def main():
    city_name = []
    coordinates = []
    with open('18城市坐标.txt', 'r', encoding='UTF-8') as f:
        lines = f.readlines()
        # 调用readlines()一次读取所有内容并按行返回list给lines
        # for循环每次读取一行
        for line in lines:
            line = line.split('\n')[0]
            line = line.split(',')
            city_name.append(line[0])
            coordinates.append([float(line[1]), float(line[2])])
    coordinates = np.array(coordinates)  # 获取30城市坐标
    nCity = coordinates.shape[0]
    distMat = getdistMat(coordinates)  # 得到距离矩阵
    tourNew = np.arange(nCity)
    tourNow = np.arange(nCity)  # 产生初始路径，返回一个初值为0、步长为1、长度为nCity的排列
    valueNow = 0
    valueNow = calTourMileage(tourNow, nCity, distMat)  # 计算当前路径的总长度
    # valueNow,tourNow=greedy(distMat, 51)
    tourBest = tourNow.copy()  # 初始化最优路径，复制 tourNow

    print(valueNow, tourNow)
    valueBest = valueNow  # 初始化最优路径的总长度，复制 valueNow
    valueNew = 0
    recordBest = []  # 初始化最优路径记录表
    recordNow = []  # 初始化当前路径记录表
    recordNew = []
    # 开始模拟退火优化过程
    tInitial, tFinal, alpha, nMarkov = initPara()
    nMarkov = nCity  # Markov链 的初值设置
    tNow = tInitial

    # 通过 交换操作 产生新路径
    while tNow > tFinal:
        # 外循环，直到当前温度达到终止温度时结束
        for i in np.arange(nMarkov):
            mutateSwap(tourNew, nCity)
            valueNew = calTourMileage(tourNew, nCity, distMat)
            deltaE = valueNew - valueNow
            if deltaE < 0:
                tourNow = tourNew.copy()
                valueNow = valueNew
                if valueNew < valueBest:  # 如果新解的目标函数好于最优解，则将新解保存为最优解
                    valueBest = valueNew
                    tourBest = tourNew.copy()
            else:  # 按一定的概率接受该解
                if np.random.rand() < np.exp(-(deltaE) / tNow):
                    valueNow = valueNew
                    tourNow = tourNew.copy()
                else:
                    tourNew = tourNow.copy()
        tNow = alpha * tNow
        # 平移当前路径，以解决变换操作避开 0,（n-1）所带来的问题，并未实质性改变当前路径。
        #tourNow = np.roll(tourNow,1)                # 循环移位函数，沿指定轴滚动数组元素
        recordBest.append(valueBest)
        recordNow.append(valueNow)
        recordNew.append(valueNew)
    # 结束模拟退火过程
    # 图形化显示优化结果
    drawtour(tourBest, valueBest, coordinates,city_name)

    drawiter(recordNow, recordBest, recordNew)
    print("路线: \n", tourBest)
    print("里程: {:.1f}".format(valueBest))


if __name__ == '__main__':
    main()

![计算迭代图