模拟退火算法（SA）求解旅行商问题（TSP）python

已于 2023-11-05 18:50:10 修改
阅读量538 收藏 6
点赞数
分类专栏： python 计算智能 文章标签： 模拟退火算法 python 算法 TSP 旅行商问题 SA 计算智能
于 2023-10-21 20:07:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_70452407/article/details/133965551
版权

目录

一、模拟退火算法求解TSP（city14）的python代码

二、city14的运行结果

三、 模拟退火算法求解TSP（city30）的python代码

四、city30的运行结果

五、模拟退火算法的python代码（类封装） 

一、模拟退火算法求解TSP（city14）的python代码

import random
import numpy as np
import math
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False


'''计算路径总路程的函数'''
def fitness(n,X,Y,X0):
    '''
    :param n: 城市数量
    :param X: n个城市的横坐标
    :param Y: n个城市的纵坐标
    :param X0: 一个解向量
    :return: 总路程
    '''
    s=0
    for i in range(n):
        if i!=n-1:
            s=s+np.sqrt((X[X0[i]]-X[X0[i+1]])**2+(Y[X0[i]]-Y[X0[i+1]])**2)
        else:
            s=s+np.sqrt((X[X0[i]]-X[X0[0]])**2+(Y[X0[i]]-Y[X0[0]])**2)
    return s


'''定义领域搜索运算操作——交换操作'''
def exchange(X0,q):
    '''
    :param X0: 一个解向量
    :param q: 指定的需要交换的数的两个位置的列表，列表长度为2
    :return: 一个领域解
    '''
    X1=X0.copy()
    temp=X1[q[0]]
    X1[q[0]]=X1[q[1]]
    X1[q[1]]=temp
    return X1


'''定义随机产生初始解的函数'''
def initialX0(n):
    '''
    :param n: 城市数量
    :return: 一个初始解
    '''
    X0=random.sample(range(n),n)
    return X0


'''模拟退火算法——TSP'''
def SA_TSP(n,X,Y,n_TK,r,T_f):
    '''
    :param n: 城市数量
    :param X: n个城市的横坐标
    :param Y: n个城市的纵坐标
    :param n_TK: 内循环的迭代次数
    :param T_down: 降温变化
    :param T_f: 终止温度
    :return: 最优路径和最短距离
    '''

    '''产生一个初始解'''
    X0=initialX0(n)
    print("初始解：\n{}".format(X0))
    print("初始解的总路程：\n{}".format(fitness(n,X,Y,X0)))

    '''初始温度'''
    T0=1000

    '''存储历史最优路径'''
    X_min=[]
    X_min.append(X0)

    '''存储历史最优距离'''
    s_min=[]
    s_min.append(fitness(n,X,Y,X0))

    k=0

    while T0>T_f:
        for i in range(n_TK):
            #随机产生两个位置
            q=random.sample(range(n),2)
            #领域运算得到一个随机领域解
            X1=exchange(X0,q)
            #计算初始解和随机领域解的目标函数值
            s1=fitness(n,X,Y,X0)
            s2=fitness(n,X,Y,X1)

            #更新历史最优解
            if s2<min(s_min):
                s_min.append(s2)
                X_min.append(X1)
            else:
                s_min.append(s_min[-1])
                X_min.append(X_min[-1])

            '''判断是否更新解'''
            if s2<s1:
                X0=X1
            else:
                E=math.exp(-(s2-s1)/T0)
                R=random.uniform(0,1)
                if E>R:
                    X0=X1

            k=k+1

        '''降温'''
        T0=T0*r

    '''绘制优化过程'''
    plt.plot(range(k+1),s_min)
    plt.grid()
    plt.title("模拟退火算法——TSP的优化过程")
    plt.xlabel("迭代次数")
    plt.ylabel("总路程")
    plt.show()

    '''绘制路线图'''
    #最优路径
    W=X_min[-1]
    for i in range(n):
        if i!=n-1:
            plt.plot([X[W[i]],X[W[i+1]]],[Y[W[i]],Y[W[i+1]]],c='plum')
        else:
            plt.plot([X[W[i]],X[W[0]]],[Y[W[i]],Y[W[0]]],c='plum')
    plt.scatter(X,Y,c='red')
    plt.title("路线图")
    plt.xlabel("x")
    plt.ylabel("y")
    plt.show()

    return X_min[-1],s_min[-1]



'''主函数'''
if __name__=="__main__":

    '''城市的数量'''
    n=14

    '''定义14个城市的坐标'''
    city_x=[16.47,16.47,20.09,22.39,25.23,22.00,20.47,17.20,16.30,14.05,16.53,21.52,19.41,20.09]
    city_y=[96.10,94.44,92.54,93.37,97.24,96.05,97.02,96.29,97.38,98.12,97.38,95.59,97.13,92.55]

    '''内循环的迭代次数'''
    n_Tk=200

    '''降温变化'''
    r=0.9

    '''终止温度'''
    T_f=0.001

    '''模拟退火算法求解TSP'''
    Xmin,smin=SA_TSP(n,city_x,city_y,n_Tk,r,T_f)

    print("最优路径：\n{}".format(Xmin))
    print("最短距离：\n{}".format(smin))

二、city14的运行结果

 

三、 模拟退火算法求解TSP（city30）的python代码

import random
import numpy as np
import math
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False


'''计算路径总路程的函数'''
def fitness(n,X,Y,X0):
    '''
    :param n: 城市数量
    :param X: n个城市的横坐标
    :param Y: n个城市的纵坐标
    :param X0: 一个解向量
    :return: 总路程
    '''
    s=0
    for i in range(n):
        if i!=n-1:
            s=s+np.sqrt((X[X0[i]]-X[X0[i+1]])**2+(Y[X0[i]]-Y[X0[i+1]])**2)
        else:
            s=s+np.sqrt((X[X0[i]]-X[X0[0]])**2+(Y[X0[i]]-Y[X0[0]])**2)
    return s


'''定义领域搜索运算操作——交换操作'''
def exchange(X0,q):
    '''
    :param X0: 一个解向量
    :param q: 指定的需要交换的数的两个位置的列表，列表长度为2
    :return: 一个领域解
    '''
    X1=X0.copy()
    temp=X1[q[0]]
    X1[q[0]]=X1[q[1]]
    X1[q[1]]=temp
    return X1


'''定义随机产生初始解的函数'''
def initialX0(n):
    '''
    :param n: 城市数量
    :return: 一个初始解
    '''
    X0=random.sample(range(n),n)
    return X0


'''模拟退火算法——TSP'''
def SA_TSP(n,X,Y,n_TK,r,T_f):
    '''
    :param n: 城市数量
    :param X: n个城市的横坐标
    :param Y: n个城市的纵坐标
    :param n_TK: 内循环的迭代次数
    :param T_down: 降温变化
    :param T_f: 终止温度
    :return: 最优路径和最短距离
    '''

    '''产生一个初始解'''
    X0=initialX0(n)
    print("初始解：\n{}".format(X0))
    print("初始解的总路程：\n{}".format(fitness(n,X,Y,X0)))

    '''初始温度'''
    T0=2000

    '''存储历史最优路径'''
    X_min=[]
    X_min.append(X0)

    '''存储历史最优距离'''
    s_min=[]
    s_min.append(fitness(n,X,Y,X0))

    k=0

    while T0>T_f:
        for i in range(n_TK):
            #随机产生两个位置
            q=random.sample(range(n),2)
            #领域运算得到一个随机领域解
            X1=exchange(X0,q)
            #计算初始解和随机领域解的目标函数值
            s1=fitness(n,X,Y,X0)
            s2=fitness(n,X,Y,X1)

            #更新历史最优解
            if s2<min(s_min):
                s_min.append(s2)
                X_min.append(X1)
            else:
                s_min.append(s_min[-1])
                X_min.append(X_min[-1])

            '''判断是否更新解'''
            if s2<s1:
                X0=X1
            else:
                E=math.exp(-(s2-s1)/T0)
                R=random.uniform(0,1)
                if E>R:
                    X0=X1

            k=k+1

        '''降温'''
        T0=T0*r

    '''绘制优化过程'''
    plt.plot(range(k+1),s_min)
    plt.grid()
    plt.title("模拟退火算法——TSP的优化过程")
    plt.xlabel("迭代次数")
    plt.ylabel("总路程")
    plt.show()

    '''绘制路线图'''
    #最优路径
    W=X_min[-1]
    for i in range(n):
        if i!=n-1:
            plt.plot([X[W[i]],X[W[i+1]]],[Y[W[i]],Y[W[i+1]]],c='plum')
        else:
            plt.plot([X[W[i]],X[W[0]]],[Y[W[i]],Y[W[0]]],c='plum')
    plt.scatter(X,Y,c='red')
    plt.title("路线图")
    plt.xlabel("x")
    plt.ylabel("y")
    plt.show()

    return X_min[-1],s_min[-1]



'''主函数'''
if __name__=="__main__":

    '''城市的数量'''
    n=30

    '''定义30个城市的坐标'''
    city_x=[41, 37, 54, 25, 7, 2, 68, 71, 54, 83, 64, 18, 22, 83, 91, 25, 24, 58, 71, 74, 87,
            18, 13, 82, 62, 58, 45,41,44, 4]
    city_y=[94, 84, 67, 62, 64, 99, 58, 44, 62, 69, 60, 54, 60, 46, 38, 38, 42, 69, 71, 78, 76,
            40, 40, 7, 32, 35, 21,26,35, 50]

    '''内循环的迭代次数'''
    n_Tk=300

    '''降温变化'''
    r=0.9

    '''终止温度'''
    T_f=0.001

    '''模拟退火算法求解TSP'''
    Xmin,smin=SA_TSP(n,city_x,city_y,n_Tk,r,T_f)

    print("最优路径：\n{}".format(Xmin))
    print("最短距离：\n{}".format(smin))

四、city30的运行结果

 

五、模拟退火算法的python代码（类封装） 

import random
import numpy as np
import math
import matplotlib.pyplot as plt
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus']=False


class SA_TSP:

    def __init__(self,n,X,Y,n_Tk,r,T_f,T0):
        self.n=n
        self.X=X
        self.Y=Y
        self.n_Tk=n_Tk
        self.r=r
        self.T_f=T_f
        self.T0=T0

    def fitness(self,X0):
        s=0
        for i in range(self.n):
            if i!=self.n-1:
                s = s + np.sqrt((self.X[X0[i]] - self.X[X0[i + 1]]) ** 2 + (self.Y[X0[i]] - self.Y[X0[i + 1]]) ** 2)
            else:
                s = s + np.sqrt((self.X[X0[i]] - self.X[X0[0]]) ** 2 + (self.Y[X0[i]] - self.Y[X0[0]]) ** 2)
        return s

    def exchange(self,X0,q):
        X1=X0.copy()
        temp = X1[q[0]]
        X1[q[0]] = X1[q[1]]
        X1[q[1]] = temp
        return X1

    def initialX0(self):
        X0=random.sample(range(self.n),self.n)
        return X0

    def SA_tsp(self):
        X0=SA_TSP.initialX0(self)
        print("初始解：\n{}".format(X0))
        print("初始解的总路程：\n{}".format(SA_TSP.fitness(self,X0)))

        '''存储历史最优路径'''
        X_min = []
        X_min.append(X0)

        '''存储历史最优距离'''
        s_min = []
        s_min.append(SA_TSP.fitness(self,X0))

        k=0

        while self.T0>self.T_f:
            for i in range(self.n_Tk):
                q=random.sample(range(self.n),2)
                X1=SA_TSP.exchange(self,X0,q)
                s1=SA_TSP.fitness(self,X0)
                s2=SA_TSP.fitness(self,X1)
                #更新历史最优解
                if s2<min(s_min):
                    s_min.append(s2)
                    X_min.append(X1)
                else:
                    s_min.append(s_min[-1])
                    X_min.append(X_min[-1])

                '''判断是否更新解'''
                if s2<s1:
                    X0=X1
                else:
                    E=math.exp(-(s2-s1)/self.T0)
                    R=random.uniform(0,1)
                    if E>R:
                        X0=X1

                k=k+1

            '''降温'''
            self.T0=self.T0*self.r

        '''绘制优化过程'''
        plt.plot(range(k+1),s_min)
        plt.grid()
        plt.title("模拟退火算法——TSP的优化过程")
        plt.xlabel("迭代次数")
        plt.ylabel("总路程")
        plt.show()

        '''绘制路线图'''
        #最优路径
        W=X_min[-1]
        for i in range(self.n):
            if i!=self.n-1:
                plt.plot([self.X[W[i]],self.X[W[i+1]]],[self.Y[W[i]],self.Y[W[i+1]]],c='plum')
            else:
                plt.plot([self.X[W[i]],self.X[W[0]]],[self.Y[W[i]],self.Y[W[0]]],c='plum')
        plt.scatter(self.X,self.Y,c='red')
        plt.title("路线图")
        plt.xlabel("x")
        plt.ylabel("y")
        plt.show()

        return X_min[-1],s_min[-1]


'''主函数'''
if __name__=="__main__":

    '''城市的数量'''
    n=30

    '''定义30个城市的坐标'''
    city_x=[41, 37, 54, 25, 7, 2, 68, 71, 54, 83, 64, 18, 22, 83, 91, 25, 24, 58, 71, 74, 87,
            18, 13, 82, 62, 58, 45,41,44, 4]
    city_y=[94, 84, 67, 62, 64, 99, 58, 44, 62, 69, 60, 54, 60, 46, 38, 38, 42, 69, 71, 78, 76,
            40, 40, 7, 32, 35, 21,26,35, 50]

    '''内循环的迭代次数'''
    n_Tk=300

    '''降温变化'''
    r=0.9

    '''终止温度'''
    T_f=0.001

    '''初始温度'''
    T0=2000

    '''创建对象'''
    city30=SA_TSP(n,city_x,city_y,n_Tk,r,T_f,T0)

    '''方法'''
    Xmin,smin=city30.SA_tsp()

    print("最优路径：\n{}".format(Xmin))
    print("最短距离：\n{}".format(smin))
天下弈星~
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python实现模拟退火算法求解TSP问题 (Implementing TSP with Simulated
禅与计算机程序设计艺术
08-22 147
作者：禅与计算机程序设计艺术 1.简介 模拟退火算法简介及其特点 模拟退火算法（Simulated annealing）是一种通过温度的变化控制搜索最优解的方法，其特点是在当前温度下，系统以一定概率接受较差解，并在一定时间内转移到较好解的过程。简单来
模拟退火算法求解旅行商问题-TSP最短路问题-Python代码
06-05
模拟退火算法（Simulated Annealing，SA）加入了Metropolis函数，该函数值决定了算法接受一个更劣解的概率，这个机制能帮助算法跳出局部最优。 本案例中以31个节点的测试数据做演示，基于简单的邻域搜索策略实现...
python实现模拟退火算法解决旅行商（TSP）问题
qq_49370210的博客
11-29 3042
TSP的难点在于随着城市数量的增加，搜索所有可能的路径将变得非常耗时，因为路径的数量是城市数量的阶乘。：在当前解的基础上进行微小的扰动，例如交换两个城市的顺序，得到一个新的解。这种随机性和“接受劣解”的策略使得模拟退火算法有可能避免陷入局部最优解，同时在搜索空间中进行广泛的探索，从而找到更优的解。算法中的温度和接受劣解的概率是关键的参数，它们影响了算法的探索性能。在TSP问题中，模拟退火算法在解决旅行商问题（TSP）时的思路是通过在解空间中进行随机游走，模拟“退火”过程中的分子在热系统中的运动。
模拟退火算法（SA）解决函数极值和TSP问题（matlab和python代码）
weixin_47736136的博客
06-06 1739
模拟退火算法SA解决函数极值和TSP问题，matlab和python代码
使用模拟退火算法解决旅行商问题(TSP)的Python实现及深度解析
qq_38334677的博客
08-29 724
由于TSP是一个NP-hard问题，找到其精确解决方案是非常计算密集型的，特别是对于大规模的城市集。P(接受新解)={1如果新解比当前解好e−ΔET否则P(\text{接受新解}) = \begin{cases} 1 & \text{如果新解比当前解好} \ e^{-\frac{\Delta E}{T}} & \text{否则} \end{cases}P(接受新解)={1e−TΔE​​如果新解比当前解好否则​。虽然它不能保证找到问题的最优解，但在许多实际情况下，它能够在合理的时间内找到一个很好的近似解。
利用遗传算法解决旅行商问题（GA-TSP）—— Python代码实现
weixin_46357639的博客
07-28 2510
利用Python编写GA-TSP算法，通过遗传算法对旅行商问题进行求解，并以29个城市为例的TSP问题进行求解
解决TSP旅行商问题3个可以用Python编程的优化路径算法
小码农的博客
02-07 1145
旅行商问题（Traveling Salesman Problem, TSP）是一个经典的组合优化问题，它要求找到访问一系列城市并返回起点的最短可能路线，同时每个城市仅访问一次。这个问题是NP-hard的，意味着没有已知的多项式时间复杂度的精确算法来解决它。
模拟退火算法求解TSP问题tsp-sa-master.zip
02-14
- 源代码文件：可能是用Python、C++或其他编程语言实现的模拟退火算法求解TSP问题的程序。这些代码会详细展示算法的各个步骤，包括初始化、迭代、新解生成、能量计算、温度更新等逻辑。 - 数据文件：可能包含一些TSP...
旅行商问题-使用模拟退火+遗传算法解决旅行商问题-求解.zip
02-08
在这个压缩文件中，“旅行商问题_使用模拟退火+遗传算法解决旅行商问题_求解”很可能是包含了关于如何应用这两种算法来解决TSP的详细步骤、代码实现以及可能的结果分析。文件可能包括了算法的设计思想、伪代码、实际...
Python编程求解旅行商（TSP）问题
03-13
在IT领域，旅行商问题（Traveling Salesman Problem, TSP）是一个经典的组合优化问题，它的目标是找到一条经过每个城市一次并返回起点的最短路径。这个问题在物流、网络设计、电路板布线等领域有广泛应用。Python...
SA_TSP_模拟退火TSP_TSP问题_智能优化算法_源码
10-02
**模拟退火算法** ...通过阅读和理解`SA_TSP.py`代码，我们可以深入学习模拟退火算法的实现细节，并且可以根据实际问题调整参数，优化求解效果。此外，这个代码也可以作为一个学习智能优化算法的实践案例。
蚁群算法优化TSP问题的完整Python代码
corn1949的博客
02-22 2019
蚁群算法优化TSP问题的完整Python代码
计算智能 | 蚁群算法——旅行商问题（TSP）python
天下弈星~的博客
12-18 2263
编写蚁群算法的python代码求解旅行商问题并进行可视化
基于模拟退火算法（SA）的TSP（Python实现）
不去幼儿园的博客
03-08 1053
基于模拟退火算法（Simulated Annealing, SA）的TSP（Traveling Salesman Problem，旅行商问题），我们涉及一种用于解决TSP的启发式优化方法。TSP是一个经典的组合优化问题，旨在寻找一条最短路径，使得旅行商可以访问每个城市恰好一次并返回起点城市。 模拟退火算法（SA）是一种经典的全局优化算法，其灵感来自固体材料的退火过程。在物理学中，高温下的固体粒子具有较高的动能，可以跳出局部能量最小值，而随着温度降低，粒子逐渐趋向稳定状态。
使用python解决TSP(旅行商问题）
热门推荐
小白
08-30 2万+
这段时间，因为要交一篇关于旅行商问题的作业，所以在github上搜索了一下，觉得用python解决比较方便，所以给大家简单的介绍一下如何使用所给的代码： 用python实现的TSP源码：      GitHub链接：https://github.com/eldrtimo/python-salesman    百度云盘链接: 这段代码使用python3实现的，可以再windows的dos环境下运
旅行商问题 python 不同算法实现
大白的博客
12-05 5135
定义：问题描述：​ 旅行商问题(Travelling Salesman Problem,TSP)又称为旅行推销员问题、货郎担问题，它是数学领域著名问题之一。假设有一个旅行商人要拜访n个城市，他必须选择所要走的路径，路径的限制是每个城市只能拜访一次，而且最后要回到原来出发的城市。路径的选择目标是使求得的路径长度为所有路径长度为所有路径之中的最小值。旅行商问题，即TSP问题，是数学领域中著名问题之一。给定nnn个城市，每个城市之间存在一定的距离，具体而言，第iii号城市到第jjj号城市的距离为aij
使用Python实现模拟退火算法解决旅行商问题：详细步骤与代码解析
qq_38334677的博客
08-29 687
模拟退火算法（Simulated Annealing, SA）是一种基于概率的全局优化算法，受到物理学中固体退火过程的启发。其基本思想是：将待优化的问题与一个物理系统的能量相对应，系统的状态与解相对应。系统的能量越低，解越优。在退火过程中，系统会随机地从一个状态跳到另一个状态。如果新状态的能量低于旧状态，系统会接受这个状态；否则，系统会以一个与温度和能量差相关的概率接受这个状态。随着时间的推移，系统的温度逐渐降低，使系统更有可能接受更低能量的状态，从而达到全局最优。
简单代码实现遗传算法解决旅行商问题（TSP）的改进（python)
wangyixin415的博客
10-16 386
而且，对于初始种群没有特别要求，即便人为给与一个已经全部为最大值（最劣）的种群，也不会过早地收敛到比较差的解。3、简单地采用 适应度=1/（本次解的路程-已知最短路程+很小的正常数），即可实现动态自适应函数，避免适应度区分度过小的问题。需要说明：上述的改进，全部都是针对称旅行商问题（STSP）的，对于非对称旅行商问题（ATSP），上述第2点改进不能使用，第5点改进不建议使用。4、使用简单的代码，既实现了轮盘赌选择，又实现了最优个体保留，还实现了外来基因引入（故意对种群的基因进行污染）。
Python爬虫与MongoDB的完美结合
最新发布
weixin_52392194的博客
08-03 812
我们掌握了在Windows和Linux系统下安装MongoDB，设计适合爬虫存储数据的写入规范，并通过实际爬虫示例展示了如何将爬取到的数据存储到MongoDB中。此外，还进行了MongoDB性能优化，提高了数据存储和查询的效率。
模拟退火（SA）算法求解旅行商（TSP）问题
06-10
好的，你的问题是关于模拟退火算法在求解旅行商问题上的应用。那么，我来简单介绍一下。 旅行商问题是指一个旅行商要拜访多个城市，且每个城市只能拜访一次，最终回到起点城市，求解最短的路线。这个问题是一个NP难问题，因此需要使用一些高效的算法来进行求解。 模拟退火算法是一种全局优化算法，它通过模拟物质在高温状态下的退火过程，以一定的概率接受劣解，从而避免陷入局部最优解。在求解旅行商问题时，模拟退火算法可以通过随机生成一条路径，并不断进行路径的变化和优化，以达到求解最短路径的目的。 具体来说，模拟退火算法在求解旅行商问题时，可以采用以下步骤： 1. 随机生成一条初始路径。 2. 对于当前路径，随机选择两个城市进行交换。 3. 计算新路径的长度。 4. 判断是否接受新路径，如果接受，则更新当前路径；如果不接受，则保留原路径。 5. 重复步骤2~4，直到满足终止条件（例如达到最大迭代次数或者路径长度足够小）。 6. 返回最终路径。 需要注意的是，模拟退火算法的效果与参数的选择有很大关系，需要根据具体情况进行调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

天下弈星~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值