基于优化A-Star算法以及模拟退火算法求解多目标路径规划问题的研究

摘要:本文针对公路修建问题提出了一种基于A-Star算法和模拟退火算法的公路修建模型。公路修建是一个涉及到资源、时间、费用和环境等多个方面的复杂问题，如何在满足修建需求的同时，尽可能减少费用和减轻环境影响，是一个重要的难题。基于此，本文运用A-Star算法和模拟退火算法，从建设费用、经济效益和环境影响三个方面进行综合考虑，不断进行调整和优化，得出了较为完美的公路修建模型。该模型考虑了公路修建费用尽可能少、道路尽可能短的情况，可以适用于不同情况下的公路修建问题。通过使用该模型，可以更加准确地预测公路修建所需的时间、费用和资源等，从而为决策者提供科学依据。在模型的分析和讨论中，本文从模型假设、变量定义、求解方法等多个方面进行了详细的阐述，为读者提供了更加深入的理解。该模型具有较高的实用性和适用性，可以为公路修建领域的研究和实践提供有益的参考。

A-Star算法求解多目标路径规划问题：本文将地图转换为可供计算的数值矩阵，将起点和终点所在的格子简化为宏观的起点和终点信息。我们将河流所在的格子标记为河流格子，在 A-Star 算法中引入启发式函数，综合崎岖程度、架桥数量、道路长度进行路径搜索，从而得到最优路径。并通过大量实验和计算，成功找到了行程较短、花费较少的路径。

模拟退火算法求解多目标路径规划问题：本文将支持城市、反对地区、开发区抽离成坐标。当道路经过这些坐标会付出一定代价或一些补偿，通过模拟退火算法获得最短路径，模拟退火算法中的温度在整个搜索空间内随机变化，而不是固定在一个点上。这使得模拟退火算法具有自适应能力，能够更好地发现全局最优解。利用模拟退火算法求得路径最优解后，根据反对地区的边缘进行回避，以减少支出。尽量在不应影响道路的长度的前提下经过开发区和支持城市。

综上所述，本文所提出的公路修建模型是一种可行的解决方案，是对公路修建问题的一种有益探索。希望本文能够为该领域的研究者和从业者提供有益的借鉴和启示。

关键词：公路修建；A-Star算法；模拟退火算法；经济效益；环境影响

1 问题的引出

某城市打算在两个距离大约100km的乡镇中间修建一条公路，修建公路基本成本是30万/公里，如果需要修建一座桥梁，则需要增加成本200万元。通过题中所给的地图对公路的建设进行参考研究，根据地图，修建的公路需要经过一些正方形的区块，区块方形根据崎岖程度分为四级0，1，2，3；每经过一个不同等级的区块方形，修建公路所需要增加的费用不同，随着崎岖等级的递增，增加的费用也逐渐递增，从0，100万，300万到500万。同时，在考虑修建公路时，不能穿过市中心（地图中的黑色圆）并且也不能出现岔路。本文将从建设费用、经济效益和环境影响三个方面来规划公路建设的影响因素。

图1 修建公路地区的地图，曲线代表河流，城市旁边的数字代表城市人口（单位：万人）

图2 修建公路地区的崎岖程度以及各地区位置图

下面是具体要求：

（1）规划一条合理的线路，在连接所选定的起点和终点的同时，尽量节省费用，并且尽量使总长度最短。

（2）考虑到政府确定的6个开发区的发展的需要。为帮助这些地区快速发展，政府将在修路的同时每经过一个开发区，财政部门将拨款500万的额外款项支持修建道路。此外，有5个城市对于修建公路这一举动表示支持态度，因此，当公路修路每经过一个支持城市，该城市将会给予300万元的建路资金进行资助。然而，有7个城市区域对于公路修建的经过持强烈反对意见，因此为完成修路计划，当每经过一个反对区域，将会在占地补偿方面多花费300万元的费用。

基于上述因素的影响，设计一条合理的公路线路连接两个城镇间选定的起点和终点。且得到的路线总长度相对较短，同时也能够最大限度地利用政府的支持和资金，降低总建设费用。

2 问题分析

基于A-Star模型求解多目标路径规划问题：要想公路建设总花费最小，就要尽量缩短规划路程、避开崎岖程度较高的路面同时尽量减少建桥次数。以地图上每一小格为一个基本单元，根据每一基本单元的地面崎岖程度抽离成一个14×25的矩阵，然后确定起点和终点分别为（6,22）和（6,2）（矩阵行与列的第一位皆从0开始计算），然后使用A-Star算法规划从起点到终点的最短路径同时确保路面崎岖程度最小。

基于模拟退火模型求解多目标路径规划问题：要想公路建设总花费最小，不仅要缩短规划路程、避开崎岖程度较高的路面、减少建桥的数量，还要尽可能的避开反对地区、通过开发区和通过支持城市。处理出的14×25数值矩阵的基础上，提供特殊区域的坐标进行模拟退火。生成尽可能多的最短路径，从这些路径中选取费用小的路径作为最优路径。

3 问题假设

（1）假设起点在其所在方格的正中央处，终点在其所在方格的顶线靠左三分之一处

（2）假设公路建设可以随意按照设计进行弯曲盘旋，路面等情况不受影响；

（3）假设每一格的边界处的崎岖程度不受其相邻格的崎岖程度影响；

（4）不考虑公路建设时候因地形过于崎岖或者其他原因导致路面坍塌等其他因素；

（5）假设起点花费为0。

4 符号说明

符号	含义	单位
Cm	修建道路的基础费用	万元
Br	修建桥的个数	座
P	经过开发区的次数	次
B	经过支持城市的个数	个
R	经过反对区域的个数	个
V	总预算	万元

5 模型的建立与求解

本题是一个经典的多目标路程规划问题，对于道路修建的规划需要综合考虑多方面因素如建设费用；经济效益；环境影响等。下面是针对该问题的分析与求解：

5.1基于A-Star模型建立与求解

5.1.1公路长度与路面崎岖程度的关系

按照题目要求，将题目中所给的地图按照崎岖程度抽离成二维数组，其中数字0表示地图该地区崎岖程度最低，随着数字增大地区的崎岖程度不断增加。将起点终点所在的方格视为起点方格和终点方格。在此基础上引用A-Star算法建立数学模型进行求解。

Step1：A-Star算法概念引入

A-Star算法[1]是一种常用的路径规划算法，适用于解决静态路网中两点之间的最短路径问题。该算法通过使用开放列表和关闭列表来跟踪搜索节点，以实现高效的路径规划。

在A-Star算法中，首先使用曼哈顿距离或欧几里德距离等来估算两点之间的距离。然后，将起点加入开放列表中，并为每个节点计算一个代价估算值(代价值)和距离估算值。代价估算值是指从起点到当前节点的距离加上从当前节点到终点的估计距离，而距离估算值是指当前节点到终点的实际距离。

接下来，从开放列表中选取代价最小的节点进行扩展。具体来说，从开放列表中选择一个节点，计算出其代价估算值和距离估算值，然后将其与终点的距离进行比较。如果选择的节点与终点的距离小于等于剩余距离，则将其加入封闭列表中，并标记为已搜索过；否则，将其加入开放列表中。

重复以上过程直到找到终点或者开放列表为空为止。此时，如果找到了终点，则可以通过回溯路径来得到从起点到终点的最短路径；否则，如果开放列表为空，则说明无法到达终点。

具体流程表示如下：

（1）初始化open表和closed表，将起点加入open表中

open表包含起点和所有走过的点，closed表包含不可通行(如墙壁)的点

（2）计算起点的值，

g为实际起点到该点的代价，如当前点到起点的路径长度

h为该点到终点的估价，如曼哈顿或欧几里得距离

（3）在open表中找到f值最小的点P，将其从open表中删除并加入closed表中

（4）针对点P的每个相邻点进行以下操作：

a.如果该点已经在closed表中，忽略该点

b.如果该点不在open表中，将其加入open表，并计算该点的f值

c.如果该点在open表中，并且新路径的f值更优，更新该点的f值，并将其父节点设置为P

（5）重复执行步骤3-4，直到终点在open表中或者open表为空(即无法到达终点)

（6）如果终点在open表中，从终点开始沿着父节点一直往回找，构成一条最短路径。

Step2：基于地面崎岖问题的A-Star算法优化

（1）根据题目中所给地图，在不考虑城市中心的情况下绘制概念图：

图3 崎岖程度概念图

（2）图3中，根据地面崎岖程度标注在矩阵中，其中空白的地方代表崎岖程度为0；根据Step1中可知估价数应该按照实际路面崎岖程度进行赋值，因此在原来普通A-Star算法的基础上，引入了路面崎岖程度的概念。不考虑河流以及市中心等其他因素，利用引入崎岖程度的A-Star算法计算出来的路径坐标为：

 （7,23）（7,22）（7,21）（7,20）（7,19）（7,18）（8,16）（8,15）（9,14）（10,13）（10,12）（10,11）（9,10）（9,9）（9，8）（9,7）（10，6）（10,5）（9,4）（8,3）（7,3）

具体如下图：

图4 利用利用引入崎岖程度的A-Star算法规划的路径（橙色）

5.1.2 桥梁与河流的关系

图5 河流路线图

在图5中，我们可以看到地图上的弯曲黑线表示河流。通过抽离的方法，我们将河流流过的小格标记出来。需要注意的是，在地图上，河流只是一条“黑线”，而经过抽离之后，河流变“宽了”。虽然这是不严谨的，但在这里我们暂时不考虑河流的宽窄，只考虑公路跨河修建而需要修建桥梁的个数。

每当修建一个桥梁时，需要增加成本200万元。此外，修建桥梁还会破坏当地生态环境，污染水质。因此，我们应该尽量减少修建桥梁的次数，以节省开支的同时保护环境。

然而，从成本的角度考虑，当修建桥梁可以避免修建像2、3级崎岖程度的路面，并且可以明显缩短修建长度时，我们可以考虑修建桥梁。这样可以在保证道路通行的前提下，降低成本并减少对环境的影响。

总之，对于地图上的河流，我们需要根据实际情况来决定是否修建桥梁。如果修建桥梁可以带来明显的经济效益和环保效益，那么我们可以考虑修建桥梁；否则，我们应该尽量避免修建桥梁。

5.1.3对最终路线的选定

首先，根据A-Star算法[2]求得的路径所在的方格如图4；

其次，在规划道路时，我们需要考虑到不能穿越市中心以及尽量减少跨越河流的次数。为了避免这些问题，我们可以使用圆弧等几何图形绕开市中心或者河流。

更具体地说，我们通过在地图上绘制出河流和市中心的位置，然后根据需要规划道路的路径。如果需要跨越河流，我们可以使用圆弧等几何图形来绕过河流，而不是直接跨越。这样可以避免对当地生态环境造成破坏，并且可以更好地保护当地的自然景观。

此外，我们还可以使用其他几何图形来绕开市中心。例如，我们可以使用曲线来连接不同地点，而不是直接通过市中心。这样可以使道路更加平滑，并且减少对市中心的影响。

因此最终路线选定如图6，公路长度约为103.3公里，成本预算3699万元。

图6 最终路线选定（图中红线）

5.2模拟退火模型建立与求解

5.2.1模拟退火算法模型引入

（1）定义问题

我们需要找到一条路径，从起点到终点，经过若干个关键点，并且这条路径要满足以下条件：

①路径总长度最短

②路径经过的关键点中，任何一个被经过时，会引发不同的奖励/扣款

③关键点的选择数量不固定

这是一个多目标路径规划问题，因此可以使用模拟退火算法来解决。

模拟退火算法[3]的基本思想是将退火过程应用于优化问题。在SA算法中，初始解被视为一个固体物质，需要经过一系列的加热和冷却操作以达到稳定状态。与固体退火不同，SA算法中的温度在整个搜索空间内随机变化，而不是固定在一个点上。这使得SA算法具有自适应能力，能够更好地发现全局最优解。模拟退火流程如下：

图7退火算法流程图

（2）确定状态空间和邻域

我们可以定义一组状态来表示某个时刻路径经过的关键点和具体路径，对于一个 14*25的地图，我们可以定义状态为：

=(,,...,,)

其中，到表示路径中经过的关键点，表示路径本身。

对于某个状态，我们可以定义邻域为：

①随机选择一个关键点，再随机选择一个相邻节点，并且与相邻/连通

②如果已存在于中，则将移动到的位置

③如果不存在于中，则将移动到的位置，同时在中添加到的路径

（3）定义目标函数

目标函数可以设为总费用（建路费用+过程增加费用-政府补贴费用-地方补贴费用+地方补偿费用），即：

200Br

其中，V为建路的费用总和，R表示路线经过反对区域的个数，Br表示修建的桥数，Cm表示公路建设所需基本费用（30万元/Km），P表示经过开发区的个数，B表示经过支持区域的个数。

我们需要优化的目标函数是路径总长度和开销最小化。

定义路径长度：对于一个状态s，我们可以计算出其路径长度，即所有在path中的节点距离之和。

定义开销：对于一个状态s，我们可以计算出其开销，即奖励/扣款的总和。

那么我们可以定义一个目标函数，其中：

其中，和是权重。我们可以试验一下不同的权重，找到适合实际问题的值。

（4）确定初始状态和温度

我们可以根据业务条件来确定初始状态，例如可以令初始状态为：起点，终点以及两个相对位置较远的城市。

温度可以根据模拟退火算法的经验公式来计算，例如T0=1000。

（5）执行模拟退火算法

具体的模拟退火优化过程可以参考以下伪代码：

s=初始状态

T=初始温度

while T > T_min:

    for i in range(iter_num):

        s_new = 随机在 s 的邻域中选择一个状态

        delta_E = f(s_new) - f(s)

        if delta_E < 0:

            s = s_new

        else:

            p = exp(-delta_E / T)

            if random() < p:

                s = s_new

T = 更新温度

    （6）结果分析

通过算法我们得出了大量数据，通过多次对比分析我们截取了长度最小的的三组数据：

表1最优路径路径

序号	路径	路径长度
1	(6, 22), (5, 22), (5, 21), (6, 21), (7, 21), (7, 22), (8, 22), (8, 21), (8, 20), (7, 20), (6, 20), (6, 2)	32
2	(6, 22), (7, 22), (8, 22), (9, 22), (10, 23), (11, 23), (11, 24), (12, 24), (13, 24), (13, 23), (12, 23), (9, 23), (6, 2)	42
3	(6, 22), (7, 22), (8, 22), (9, 22), (9, 21), (9, 20), (10, 20), (10, 21), (11, 21), (12, 21), (12, 22), (12, 23), (12, 24), (11, 24), (10, 24), (10, 23), (11, 23), (11, 22), (10, 22), (6, 2)	44

可以得出从起点开始到终点最短路径为(6, 22), (5, 22), (5, 21), (6, 21), (7, 21), (7, 22), (8, 22), (8, 21), (8, 20), (7, 20), (6, 20), (6, 2)

(7)对最终路线的选定

首先，将模拟退火生成的最短路径中路径长度最短的路线选出来作为最优路径；

其次，在规划道路时，应该尽可能从崎岖程度低的位置穿过河流，将垂直的道路改成有弧度的和直线进一步减少道路的长度。当格子内有存在反对地区，应当尽量沿着反对地区的边缘铺路来减少费用。

6 模型总结

本文通过对已知给定起点与终点的公路维修问题进行展开研究[4]，通过A-star算法以及退火算法建立相关数学模型。该模型能够较为有效地解决公路之间最少花费与最短路程的问题，且针对于该模型，我们已经通过不断地实验探索得到了验证。本文的主要贡献在于提出了一种新的思路和方法，为相关领域的研究提供了一份新的参考。

首先，本文通过对问题的背景和相关理论知识进行详细的分析。然后，利用已知的算法建立相关数学模型，以便对该问题进行更深入的研究。本文提出的模型基于A-star算法和退火算法两种算法的结合，具有较高的准确性和可靠性。而且在实验中，我们通过对该模型进行推理验证，得出的结果证实我们在本文中所建立的模型能够有效地解决题目中的原问题。

当然，本文的内容部分仍存在着一些不足之处，例如将地图抽离成二维数组会使得地图的细节被忽视，模型的复杂度较高，处理较为复杂，需要较多的计算验证进行求解；同时，本文所建立的模型的应用范围仍较小，还需要对其进一步的拓展和完善。未来，我们将针对这些问题不断地进行改进和优化，以此来提高该模型的应用价值，致力于解决更多相关问题。

总而言之，本文所建立的数学模型为解决公路修建问题提供了一种较新的方法和思路，具有一定的理论参考和实际意义。希望本文的研究内容能够为相关领域的学者和研究人员提供一定的参考效果。

7 参考文献

[1]胡杰,朱琪,陈锐鹏,等. 引入必经点约束的智能汽车全局路径规划[J]. 汽车工程, 2023, 45(3): 350-360.

[2]余修武,穆静,刘永. 基于遗传模拟退火优化的Dv-Hop定位算法[J]. 华中科技大学学报(自然科学版): 1-8.

[3]钱叶霞,陈子敬. 基于改进模拟退火算法的配送路径优化研究[J]. 中国商论, 2023, (8): 86-89.

[4]吕军威,汪景. 地铁车站步行交通网络引导标识诱导强度设计[J]. 铁道运输与经济, 2023, 45(4): 141-149.

#A-Star算法
import heapq

# 定义地图矩阵,按照地面崎岖程度对矩阵进行赋值
map_matrix = [
[3,3,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[3,3,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[2,2,3,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0],
[1,1,0,0,1,2,1,0,1,0,0,0,0,0,1,1,3,2,1,0,0,0,0,0,0],
[1,0,0,0,3,3,3,0,0,1,1,1,0,0,1,3,3,1,0,0,0,0,0,0,0],
[0,0,0,2,3,3,1,0,0,0,2,2,1,2,2,3,1,0,0,0,0,0,0,0,0],
[0,0,0,3,3,3,2,1,0,3,3,3,3,3,2,1,0,0,0,0,0,0,0,0,0],
[0,0,0,0,3,3,2,2,2,3,3,3,3,2,1,0,0,0,1,0,0,0,0,0,0],
[0,0,0,0,2,1,0,0,0,0,1,2,2,1,1,1,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0,0,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]

#print(map_matrix)
# 定义起点和终点
start_pos = (6, 22)
end_pos = (6, 2)

# 定义节点类
class Node:
    def __init__(self, pos, g, h, parent=None):
        self.pos = pos
        self.g = g
        self.h = h
        self.f = g + h
        self.parent = parent

    def __lt__(self, other):
        return self.f < other.f

# 定义启发式函数
def calc_heuristic(pos):
    return abs(pos[0] - end_pos[0]) + abs(pos[1] - end_pos[1])

# 定义邻居节点生成函数
def generate_neighbors(node):
    neighbors = []
    x, y = node.pos
    if x > 0:
        neighbors.append((x - 1, y))  # 左
    if x < 24:
        neighbors.append((x + 1, y))  # 右
    if y > 0:
        neighbors.append((x, y - 1))  # 上
    if y < 13:
        neighbors.append((x, y + 1))  # 下
    return neighbors

# 实现A*算法
def a_star():
    open_list = []
    heapq.heappush(open_list, Node(start_pos, 0, calc_heuristic(start_pos)))
    closed_list = set()

    while open_list:
        node = heapq.heappop(open_list)
        if node.pos == end_pos:
            return node

        closed_list.add(node.pos)
        for neighbor_pos in generate_neighbors(node):
            if neighbor_pos in closed_list:
                continue
            g = node.g + map_matrix[neighbor_pos[0]][neighbor_pos[1]]
            h = calc_heuristic(neighbor_pos)
            neighbor = Node(neighbor_pos, g, h, node)
            idx = None
            for i, n in enumerate(open_list):
                if n.pos == neighbor.pos:
                    idx = i
                    break
            if idx is not None and open_list[idx].f <= neighbor.f:
                continue
            heapq.heappush(open_list, neighbor)

    return None

# 解析最短路线
def parse_path(node):
    path = [node.pos]
    while node.parent:
        node = node.parent
        path.append(node.pos)
    path.reverse()
    return path

if __name__ == '__main__':
    result = a_star()
    path = parse_path(result)
    print('Path:', path)
#print('Total Cost:', result.g)

import random
import math

# 地图数据
map_data = [
[3,3,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[3,3,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[2,2,3,0,0,1,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0],
[1,1,0,0,1,2,1,0,1,0,0,0,0,0,1,1,3,2,1,0,0,0,0,0,0],
[1,0,0,0,3,3,3,0,0,1,1,1,0,0,1,3,3,1,0,0,0,0,0,0,0],
[0,0,0,2,3,3,1,0,0,0,2,2,1,2,2,3,1,0,0,0,0,0,0,0,0],
[0,0,0,3,3,3,2,1,0,3,3,3,3,3,2,1,0,0,0,0,0,0,0,0,0],
[0,0,0,0,3,3,2,2,2,3,3,3,3,2,1,0,0,0,1,0,0,0,0,0,0],
[0,0,0,0,2,1,0,0,0,0,1,2,2,1,1,1,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,1,1,0,0,1,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,1,1,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0,0,3,3,3,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]
# 模拟退火算法参数
initial_temperature = 1000  # 初始温度
cooling_rate = 0.99  # 降温速率
iterations = 1000  # 迭代次数

# 路线规划函数
def simulated_annealing():
    # 初始化
    temperature = initial_temperature
    current_path = generate_initial_solution()
    best_path = current_path.copy()
    best_distance = calculate_total_distance(best_path)

    # 模拟退火主循环
    while temperature > 1:
        for i in range(iterations):
            # 生成新解
            new_path = generate_neighbor_solution(current_path)
            new_distance = calculate_total_distance(new_path)

            # 计算能量差
            energy_difference = new_distance - best_distance

            # 根据能量差和温度确定是否接受新解
            if energy_difference < 0 or random.random() < math.exp(-energy_difference / temperature):
                current_path = new_path
                best_distance = new_distance

                # 更新最优解
                if best_distance < calculate_total_distance(best_path):
                    best_path = current_path.copy()

        # 降温
        temperature *= cooling_rate

    return best_path, best_distance

# 生成初始解
def generate_initial_solution():
    initial_path = [(6, 22)]  # 起点为(0, 0)
    while len(initial_path) < 14 * 25:
        x, y = initial_path[-1]
        neighbors = [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]
        valid_neighbors = [(nx, ny) for nx, ny in neighbors if 0 <= nx < 14 and 0 <= ny < 25 and (nx, ny) not in initial_path]
        if valid_neighbors:
            next_position = random.choice(valid_neighbors)
            initial_path.append(next_position)
        else:
            break
    initial_path.append((6, 2))  # 添加终点
    return initial_path

# 生成邻域解
def generate_neighbor_solution(path):
    new_path = path.copy()
    index1 = random.randint(1, len(new_path) - 2)
    index2 = random.randint(1, len(new_path) - 2)
    new_path[index1], new_path[index2] = new_path[index2], new_path[index1]
    return new_path

# 计算总距离
def calculate_total_distance(path):
    total_distance = 0
    for i in range(len(path) - 1):
        x1, y1 = path[i]
        x2, y2 = path[i + 1]
        distance = abs(x2 - x1) + abs(y2 - y1)
        total_distance += distance
    return total_distance

# 生成最短路径
best_path, best_distance = simulated_annealing()

# 输出结果
print("最短路径：", best_path)
print("最短距离：", best_distance)