模拟退火算法- 最短路径问题
模拟退火算法并不是一个独立的算法，他只是算法的框架，它可以和任意的数值算法绑定在一起，比如说和梯度下降发、蚁群和爬山法绑定到一起。
退火算法思想
现在有函数曲线如上图，X(n)是横坐标的值，当前的代价值是E(n)。下一个点是X(n+1)，对应的能力是E(n+1)。这时候X(n)前进到X(n+1)，这时候能量下降了( E(n+1) < E(n) )，这个前进肯定要做，但是如果是另外一种情况，如下红色箭头表示。
这时候明显看到能力E是增高了，如果是梯度下降法，这个时候梯度为0了肯定不能往X(u+1)方向走，这时候可以结合退火方法，通过一个概率来判断是否该前进，这个概率和温度相关。这时候我们前进到局部最小值时候，可能会跳出这个局部最小值，跳到全局最小的地方。
退火算法创始者提出，1、初始温度T设置了，每次迭代进行降低问题，降温过程越慢我们越能得到高质量结果；2、初始温度也高，小球也容易跳到全局最小值；
前面我们提到一个关键点就是概率，这个概率提示我们是否前进，概率公式如果能力降低，百分百前进，如果能力变高，概率P = ：
退火算法一般分为外循环和内循环。内循环是在温度一样，进行判断最小能量；外循环降低一下温度，在进行这个内循环。
参考：
https://zhuanlan.zhihu.com/p/29390935
import numpy as np
coordinates = np.array([[565.0,575.0],[25.0,185.0],[345.0,750.0],[945.0,685.0],[845.0,655.0],
[880.0,660.0],[25.0,230.0],[525.0,1000.0],[580.0,1175.0],[650.0,1130.0],
[1605.0,620.0],[1220.0,580.0],[1465.0,200.0],[1530.0, 5.0],[845.0,680.0],
[725.0,370.0],[145.0,665.0],[415.0,635.0],[510.0,875.0],[560.0,365.0],
[300.0,465.0],[520.0,585.0],[480.0,415.0],[835.0,625.0],[975.0,580.0],
[1215.0,245.0],[1320.0,315.0],[1250.0,400.0],[660.0,180.0],[410.0,250.0],
[420.0,555.0],[575.0,665.0],[1150.0,1160.0],[700.0,580.0],[685.0,595.0],
[685.0,610.0],[770.0,610.0],[795.0,645.0],[720.0,635.0],[760.0,650.0],
[475.0,960.0],[95.0,260.0],[875.0,920.0],[700.0,500.0],[555.0,815.0],
[830.0,485.0],[1170.0, 65.0],[830.0,610.0],[605.0,625.0],[595.0,360.0],
[1340.0,725.0],[1740.0,245.0]])
def getdistmat(coordinates):
num = coordinates.shape[0]
distmat = np.zeros((52,52))
for i in range(num):
for j in range(i,num):
distmat[i][j] = distmat[j][i]=np.linalg.norm(coordinates[i]-coordinates[j])
return distmat
def initpara():
alpha = 0.99
t = (1,100)
markovlen = 10000
return alpha,t,markovlen
num = coordinates.shape[0]
distmat = getdistmat(coordinates)
solutionnew = np.arange(num)
valuenew = np.max
solutioncurrent = solutionnew.copy()
valuecurrent = np.max
solutionbest = solutionnew.copy()
valuebest = np.max
alpha,t2,markovlen = initpara()
t = t2[1]
result = [] #记录迭代过程中的最优解
while t > t2[0]:
for i in np.arange(markovlen):
#下面的两交换和三角换是两种扰动方式，用于产生新解
if np.random.rand() > 0.5:# 两交换
# np.random.rand()产生[0, 1)区间的均匀随机数
while True:#产生两个不同的随机数
loc1 = np.int(np.ceil(np.random.rand()*(num-1)))
loc2 = np.int(np.ceil(np.random.rand()*(num-1)))
if loc1 != loc2:
break
solutionnew[loc1],solutionnew[loc2] = solutionnew[loc2],solutionnew[loc1]
else: #三交换
while True:
loc1 = np.int(np.ceil(np.random.rand()*(num-1)))
loc2 = np.int(np.ceil(np.random.rand()*(num-1)))
loc3 = np.int(np.ceil(np.random.rand()*(num-1)))
if((loc1 != loc2)&(loc2 != loc3)&(loc1 != loc3)):
break
# 下面的三个判断语句使得loc1 loc2:
loc1,loc2 = loc2,loc1
if loc2 > loc3:
loc2,loc3 = loc3,loc2
if loc1 > loc2:
loc1,loc2 = loc2,loc1
#下面的三行代码将[loc1,loc2)区间的数据插入到loc3之后
tmplist = solutionnew[loc1:loc2].copy()
solutionnew[loc1:loc3-loc2+1+loc1] = solutionnew[loc2:loc3+1].copy()
solutionnew[loc3-loc2+1+loc1:loc3+1] = tmplist.copy()
valuenew = 0
for i in range(num-1):
valuenew += distmat[solutionnew[i]][solutionnew[i+1]]
valuenew += distmat[solutionnew[0]][solutionnew[51]]
if valuenew < valuecurrent: #接受该解
#更新solutioncurrent 和solutionbest
valuecurrent = valuenew
solutioncurrent = solutionnew.copy()
if valuenew < valuebest:
valuebest = valuenew
solutionbest = solutionnew.copy()
else:#按一定的概率接受该解
if np.random.rand() < np.exp(-(valuenew-valuecurrent)/t):
valuecurrent = valuenew
solutioncurrent = solutionnew.copy()
else:
solutionnew = solutioncurrent.copy()
t = alpha*t
result.append(valuebest)
print( t) #程序运行时间较长，打印t来监视程序进展速度
plot(np.array(result))
ylabel("bestvalue")
xlabel("t")
--------------------------------------------------------------------------- TypeError Traceback (most recent call last)in () 85 valuenew += distmat[solutionnew[0]][solutionnew[51]] 86 ---> 87 if valuenew < valuecurrent: #接受该解 88 #更新solutioncurrent 和solutionbest 89 valuecurrent = valuenew TypeError: '<' not supported between instances of 'float' and 'function'
In [5]:
from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
import math
#define aim function
def aimFunction(x):
y=x**3-60*x**2-4*x+6
return y
x=[i/10 for i in range(1000)]
y=[0 for i in range(1000)]
for i in range(1000):
y[i]=aimFunction(x[i])
plt.plot(x,y)
plt.show()
In [8]:
T=1000 #initiate temperature
Tmin=10 #minimum value of terperature
x=np.random.uniform(low=0,high=100)#initiate x
k=50 #times of internal circulation
y=0#initiate result
t=0#time
while T>=Tmin:
for i in range(k):
#calculate y
y=aimFunction(x)
#generate a new x in the neighboorhood of x by transform function
xNew=x+np.random.uniform(low=-0.055,high=0.055)*T
if (0<=xNew and xNew<=100):
yNew=aimFunction(xNew)
if yNew-y<0:
x=xNew
else:
#metropolis principle
p=math.exp(-(yNew-y)/T)
r=np.random.uniform(low=0,high=1)
if r
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
40.15819373723291 -32153.127300599775
In [9]:
x
Out[9]:
40.15819373723291
退火算法求解TSP旅行商问题 https://zhuanlan.zhihu.com/p/29390935
In [12]:
import os
import sys
import math
import numpy as np
import matplotlib.pyplot as plt
from random import choice, shuffle, sample, uniform
#假设下面是五个地点的距离对称矩阵(Wij = Wji)
names = ['重庆','上海','北京','广州','昆明']
arr = ([0,50,30,10,10],
[50,0,60,30,20],
[30,60,0,80,70],
[20,30,80,0,60],
[10,20,70,60,0])
num = len(arr)
print("模拟退火算法查找最短路径：")
### 参数：最小路径的最后一个节点和邻域
def valSimulateAnnealSum(curnode, nextnodeList, t):
if nextnodeList == None or len(nextnodeList) < 1:
print("empty")
return 0
maxcost = sys.maxsize
retnode = 0
for node in nextnodeList:
# print "curnode : ",curnode ," node: " ,node ," mincost : ",mincost
t *= 0.98 ## 退火因子
if arr[curnode][node] < maxcost:
maxcost = arr[curnode][node]
retnode = node
## 以一定的概率接受较差的解
else:
#r = uniform(0, 1)
r = math.exp((arr[curnode][node] - maxcost)/t)
if arr[curnode][node] > maxcost and t > t_min and math.exp((arr[curnode][node] - maxcost) / t) > r:
#print " t = " ,t , "maxcost = ", maxcost , " arr = " ,arr[curnode][node], " exp = ",math.exp((arr[curnode][node] - maxcost)/t) , " r = ",r , "t_min = " ,t_min
retnode = node
maxcost = arr[curnode][node]
return(retnode, maxcost, t)
return (retnode, maxcost, t)
indexList = [i for i in range(num)] ### 原始的节点序列
selectedList = [] ## 选择好的元素
### 具体思想是： 从剩余的元素中随机选择十分之一的元素，作为邻域。然后从邻域中选择一个元素作为已经构建好的最小路径的下一个节点，
# 使得该路径
mincost = sys.maxsize ###最小的花费
count = 0 ### 计数器
t = 100 ## 初始温度
t_min = 50 ## 最小温度
while count < num:
count += 1
### 构建一个邻域: 如果indexList中元素个数大于10个，则取样的个数为剩余元素个数的十分之一的整数。否则为剩余元素个数对10的取余数
leftItemNum = len(indexList)
# print "leftItemNum:" ,leftItemNum
#nextnum = leftItemNum // 10 if leftItemNum >= 10 else leftItemNum % 10
#nextnodeList = sample(indexList, nextnum) ### 从剩余的节点中选出nextnum个节点
if leftItemNum < 2:
leftItemNum = 1
else:
leftItemNum -= 1
nextnodeList = sample(indexList, leftItemNum)
if len(selectedList) == 0:
item = choice(nextnodeList)
selectedList.append(item)
indexList.remove(item)
mincost = 0
continue
curnode = selectedList[len(selectedList) - 1]
# print "nextnodeList:" ,nextnodeList
nextnode, maxcost, t = valSimulateAnnealSum(curnode, indexList, t) ### 对待选的序列路径求和
### 将返回的路径值添加到原来的路径值上，同时，在剩余的节点序列中，删除nextnode节点
mincost += maxcost
indexList.remove(nextnode)
selectedList.append(nextnode)
print("最合适的路径为：", selectedList)
print("对应城市",names)
print("路径节点个数：", len(selectedList))
print("最小花费为：", mincost)
模拟退火算法查找最短路径：
最合适的路径为： [2, 0, 3, 1, 4]
对应城市 ['重庆', '上海', '北京', '广州', '昆明']
路径节点个数： 5
最小花费为： 90
In [21]:
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Time : 2019/2/21 11:32
# @Author : liujiantao
# @Site :
# @File : tmp.py
# @Software: PyCharm
#!/usr/bin/python
# -*-coding: UTF-8 -*-
import os
import sys
import math
import numpy as np
import matplotlib.pyplot as pl
sys.path.append(os.path.abspath("."))
from random import choice,shuffle,sample,uniform
"""
坐标类
"""
class Point:
x = 0 # 横坐标
y = 0 # 纵坐标
def __init__(self, x, y):
self.x = int(x)
self.y = int(y)
def printvar(self):
print("x=%d y=%d" % (self.x, self.y))
"""
本程序用于实现模拟退火算法计算
最短路径问题
"""
filename = "./climbing_method_testdata.txt";
lines = open(filename).readlines();
list=[]
## 读取数据
for line in lines[6:len(lines)-1]:
params = line.strip().split()
point = Point(params[1],params[2])
list.append(point)
# print( len(list) )
## 计算任意两点间的距离
num = len(list)
arr = [[ col for col in range(num)] for row in range(num)]
valstr = ""
for row in range(num):
for col in range(num):
if col == row:
arr[row][col] = 0
p1 = list[row]
p2 = list[col]
arr[row][col] = round(math.sqrt(math.pow((p1.x - p2.x),2) + math.pow((p1.y - p2.y),2)),2) ### 求欧式距离，保留2位小数
## print( the matrix for check)
"""
for row in range(num):
for col in range(num):
if (col+1)%10 == 0 :
print( valstr + "\n")
valstr = ""
valstr += str(arr[row][col]) + ","
"""
print( "模拟退火算法查找最短路径：")
### 参数：最小路径的最后一个节点和邻域
def valSimulateAnnealSum(curnode,nextnodeList,t):
if nextnodeList == None or len(nextnodeList) < 1 :
print( "empty")
return 0
maxcost = sys.maxsize
retnode = 0
for node in nextnodeList:
# print( "curnode : ",curnode ," node: " ,node ," mincost : ",mincost )
t *= 0.98 ## 退火因子
if arr[curnode][node] < maxcost :
maxcost = arr[curnode][node]
retnode = node
## 以一定的概率接受较差的解
else:
r = uniform(0,1)
if arr[curnode][node] > maxcost and t > t_min and math.exp(( arr[curnode][node] - maxcost ) / t) > r:
# print( " t = " ,t , "maxcost = ", maxcost , " arr = " ,arr[curnode][node], " exp = ",math.exp((arr[curnode][node] - maxcost)/t) , " r = ",r , "t_min = " ,t_min)
retnode = node
maxcost = arr[curnode][node]
return (retnode,maxcost,t)
return (retnode,maxcost,t)
indexList = [ i for i in range(num)] ### 原始的节点序列
selectedList = [] ## 选择好的元素
### 具体思想是： 从剩余的元素中随机选择十分之一的元素，作为邻域。然后从邻域中选择一个元素作为已经构建好的最小路径的下一个节点，使得该路径
mincost = sys.maxsize ###最小的花费
count = 0 ### 计数器
t = 100 ## 初始温度
t_min = 50 ## 最小温度
while count < num:
count += 1
### 构建一个邻域: 如果indexList中元素个数大于10个，则取样的个数为剩余元素个数的十分之一。否则为剩余元素个数对10的取余数
leftItemNum = len(indexList)
# print( "leftItemNum:" ,leftItemNum)
nextnum = leftItemNum//10 if leftItemNum >= 10 else leftItemNum%10
nextnodeList = sample(indexList,nextnum) ### 从剩余的节点中选出nextnum个节点
if len(selectedList) == 0 :
item = choice(nextnodeList)
selectedList.append(item)
indexList.remove(item)
mincost = 0
continue
curnode = selectedList[len(selectedList) - 1]
# print( "nextnodeList:" ,nextnodeList)
nextnode, maxcost ,t = valSimulateAnnealSum(curnode,nextnodeList,t) ### 对待选的序列路径求和
### 将返回的路径值添加到原来的路径值上，同时，在剩余的节点序列中，删除nextnode节点
mincost += maxcost
indexList.remove(nextnode)
selectedList.append(nextnode)
print( "最合适的路径为：" ,selectedList )
print( "路径节点个数：" ,len(selectedList))
print( "最小花费为：" , mincost)
print( "尝试次数:", count)
#### 画图 #####
#plt.figure(1)
x = []
y = []
for i in selectedList :
x.append(list[i].x)
y.append(list[i].y)
#plt.plot(x,y)
#plt.show()
print( "x: ",x)
print( "y: " ,y)
################### 爬山法求全局最短路径 #######
### 参数：最小路径的最后一个节点和邻域
def valHillClimbSum(curnode,nextnodeList):
if nextnodeList == None or len(nextnodeList) < 1 :
print( "empty")
return 0
maxcost = sys.maxsize
retnode = 0
for node in nextnodeList:
# print( "curnode : ",curnode ," node: " ,node ," mincost : ",mincost )
if arr[curnode][node] < maxcost :
maxcost = arr[curnode][node]
retnode = node
else:
return (retnode,maxcost)
return (retnode,maxcost)
print( "\n\n爬山法算法求全局最短路径")
cost = 0
slist = []
leftnodeList = [ i for i in range(num)] ### 原始的节点序列
finalcost = 0
count = 0
while count < num:
count += 1
### 构建一个邻域: 如果indexList中元素个数大于10个，则取样的个数为剩余元素个数的十分之一。否则为剩余元素个数对10的取余数
leftItemNum = len(leftnodeList)
nextnum = leftItemNum//10 if leftItemNum >= 10 else leftItemNum%10
nodeList = sample(leftnodeList,nextnum) ### 从剩余的节点中选出nextnum个节点
if len(slist) == 0 :
item = choice(nodeList)
slist.append(item)
nodeList.remove(item)
finalcost = 0
continue
curnode = slist[len(slist) - 1]
# print( "leftnodeList:" ,leftnodeList)
nextnode, maxcost = valHillClimbSum(curnode,nodeList) ### 对待选的序列路径求和
# print( "nextnode: " , nextnode ," maxcost : " ,maxcost)
### 将返回的路径值添加到原来的路径值上，同时，在剩余的节点序列中，删除nextnode节点
finalcost += maxcost
leftnodeList.remove(nextnode)
slist.append(nextnode)
print( "最合适的路径为：" ,slist )
print( "路径节点个数：" ,len(slist))
print( "最小花费为：" , finalcost)
print( "尝试次数:", count)
#### 画图 #####
#plt.figure(2)
x1 = []
y1 = []
for i in slist :
x1.append(list[i].x)
y1.append(list[i].y)
print( ("x1 = ",x1))
print( ("y1 = ",y1))
模拟退火算法查找最短路径：
最合适的路径为： [229, 42, 222, 120, 62, 224, 169, 236, 18, 72, 202, 95, 204, 48, 46, 67, 56, 55, 43, 41, 39, 30, 27, 26, 19, 131, 133, 136, 141, 205, 252, 210, 209, 251, 207, 247, 253, 254, 249, 230, 244, 238, 231, 233, 227, 218, 212, 220, 225, 214, 228, 235, 242, 243, 245, 250, 246, 248, 257, 2, 0, 274, 6, 11, 12, 261, 258, 262, 272, 270, 16, 17, 21, 119, 156, 151, 118, 154, 124, 126, 132, 129, 127, 123, 128, 34, 117, 86, 81, 74, 70, 73, 76, 96, 93, 94, 78, 80, 82, 88, 109, 107, 103, 106, 171, 167, 168, 162, 174, 182, 179, 178, 149, 175, 173, 102, 99, 97, 92, 98, 75, 77, 89, 90, 170, 165, 161, 101, 79, 87, 65, 63, 61, 57, 53, 45, 52, 44, 38, 47, 51, 50, 59, 58, 64, 84, 83, 159, 105, 100, 115, 157, 180, 177, 176, 184, 163, 113, 155, 150, 153, 121, 24, 130, 22, 135, 134, 152, 269, 15, 271, 14, 10, 138, 265, 20, 268, 275, 276, 8, 273, 259, 255, 279, 206, 213, 215, 216, 201, 198, 145, 142, 144, 146, 147, 266, 143, 203, 211, 223, 226, 217, 221, 191, 197, 196, 195, 256, 240, 278, 7, 9, 3, 140, 260, 277, 148, 267, 200, 188, 189, 194, 137, 183, 172, 71, 187, 186, 110, 122, 181, 193, 112, 108, 111, 60, 66, 114, 190, 219, 160, 139, 5, 31, 125, 158, 29, 37, 28, 33, 54, 32, 85, 199, 185, 264, 263, 40, 241, 239, 13, 49, 104, 68, 23, 1, 237, 232, 116, 208, 69, 91, 166, 164, 192, 234, 4, 25, 35, 36]
路径节点个数： 280
最小花费为： 13482.900000000003
尝试次数: 280
x: [260, 56, 252, 104, 40, 260, 72, 284, 156, 8, 196, 16, 212, 40, 40, 16, 32, 32, 40, 56, 56, 104, 124, 132, 148, 156, 172, 172, 180, 220, 228, 236, 236, 236, 228, 260, 228, 236, 260, 276, 276, 284, 276, 276, 260, 236, 228, 228, 260, 236, 260, 284, 280, 276, 276, 260, 268, 252, 228, 270, 288, 228, 236, 204, 196, 212, 228, 204, 212, 196, 172, 164, 148, 104, 104, 124, 104, 124, 104, 124, 164, 140, 132, 104, 132, 64, 56, 40, 32, 8, 8, 8, 8, 24, 24, 16, 24, 32, 32, 40, 56, 56, 56, 72, 80, 72, 64, 104, 104, 124, 132, 140, 148, 124, 88, 56, 56, 32, 32, 44, 16, 8, 44, 44, 80, 92, 104, 56, 32, 40, 24, 32, 48, 32, 32, 40, 32, 40, 56, 40, 32, 32, 56, 40, 32, 32, 32, 104, 72, 56, 48, 104, 124, 132, 124, 124, 104, 56, 124, 124, 124, 104, 156, 148, 164, 172, 172, 124, 180, 188, 204, 196, 212, 172, 180, 140, 180, 236, 246, 228, 220, 228, 236, 280, 228, 236, 228, 228, 188, 172, 172, 180, 172, 172, 172, 180, 180, 204, 228, 260, 260, 236, 236, 162, 172, 172, 180, 228, 284, 260, 228, 220, 256, 180, 220, 252, 164, 180, 180, 128, 136, 180, 172, 124, 80, 8, 120, 124, 56, 104, 124, 172, 48, 48, 48, 56, 16, 56, 148, 228, 104, 180, 246, 104, 116, 104, 104, 56, 116, 80, 32, 90, 40, 180, 132, 188, 196, 56, 288, 284, 188, 40, 64, 8, 172, 288, 284, 276, 56, 236, 8, 44, 80, 104, 156, 284, 256, 140, 64, 56]
y: [77, 121, 21, 113, 99, 37, 25, 69, 145, 73, 49, 17, 65, 161, 145, 109, 121, 129, 121, 129, 145, 161, 169, 169, 145, 137, 125, 101, 69, 73, 85, 61, 69, 85, 77, 109, 93, 93, 93, 77, 93, 85, 69, 53, 61, 29, 53, 21, 45, 45, 69, 61, 109, 101, 85, 85, 97, 101, 109, 133, 149, 145, 169, 169, 169, 117, 117, 109, 145, 145, 145, 145, 169, 105, 89, 93, 97, 117, 145, 145, 137, 137, 145, 137, 137, 157, 97, 73, 57, 57, 89, 65, 49, 17, 25, 25, 45, 49, 65, 51, 57, 49, 41, 49, 25, 9, 21, 33, 57, 45, 61, 65, 85, 69, 49, 33, 9, 17, 25, 11, 57, 41, 43, 35, 25, 9, 41, 25, 41, 63, 89, 97, 99, 113, 145, 137, 153, 129, 153, 153, 161, 169, 113, 113, 89, 81, 73, 65, 41, 17, 83, 81, 61, 81, 77, 29, 25, 73, 101, 85, 125, 121, 169, 137, 169, 109, 117, 109, 125, 145, 145, 161, 169, 85, 93, 145, 117, 145, 141, 161, 145, 125, 101, 133, 69, 53, 45, 37, 41, 45, 61, 61, 53, 69, 77, 101, 53, 57, 61, 29, 53, 37, 21, 9, 37, 29, 29, 101, 101, 129, 169, 169, 141, 77, 125, 125, 81, 109, 37, 9, 9, 21, 93, 37, 41, 81, 9, 21, 65, 129, 53, 21, 73, 51, 63, 105, 97, 81, 9, 29, 49, 85, 157, 169, 145, 73, 153, 161, 161, 157, 137, 165, 83, 45, 21, 93, 101, 137, 109, 93, 169, 169, 41, 109, 169, 129, 77, 61, 89, 77, 97, 27, 9, 17, 25, 53, 157, 169, 165, 169]
爬山法算法求全局最短路径
最合适的路径为： [245, 132, 200, 262, 135, 4, 227, 276, 1, 209, 254, 106, 121, 61, 71, 187, 112, 162, 198, 141, 116, 64, 154, 24, 271, 2, 7, 139, 203, 234, 129, 25, 13, 30, 117, 39, 119, 122, 87, 107, 47, 48, 42, 54, 68, 45, 82, 173, 102, 98, 161, 218, 43, 179, 86, 167, 97, 66, 105, 109, 56, 17, 251, 250, 188, 192, 204, 279, 145, 147, 228, 247, 6, 275, 21, 19, 239, 270, 217, 38, 14, 258, 241, 11, 208, 257, 210, 278, 111, 70, 133, 264, 216, 163, 171, 150, 157, 260, 149, 178, 123, 113, 81, 177, 205, 215, 273, 242, 238, 274, 249, 246, 225, 73, 63, 65, 170, 110, 153, 126, 34, 131, 23, 259, 219, 202, 252, 8, 255, 143, 144, 148, 197, 164, 168, 267, 265, 256, 244, 223, 142, 120, 33, 49, 253, 248, 266, 268, 206, 18, 15, 115, 114, 44, 155, 130, 134, 62, 207, 240, 58, 90, 26, 156, 127, 125, 28, 22, 277, 237, 32, 91, 88, 51, 78, 172, 53, 93, 94, 84, 263, 245, 222, 191, 199, 214, 103, 182, 169, 101, 193, 137, 136, 212, 194, 195, 165, 95, 83, 3, 10, 183, 186, 89, 60, 80, 181, 180, 128, 50, 41, 158, 166, 108, 52, 99, 40, 175, 118, 55, 104, 74, 77, 67, 189, 220, 224, 174, 59, 79, 75, 29, 16, 31, 46, 151, 261, 176, 196, 138, 146, 221, 272, 35, 160, 92, 230, 159, 100, 96, 20, 190, 201, 0, 5, 184, 232, 243, 185, 152, 69, 72, 226, 37, 236, 269, 85, 211, 124, 140, 213, 36, 12, 9, 27, 76, 231, 235, 233, 229]
路径节点个数： 280
最小花费为： 23108.940000000006
尝试次数: 280
('x1 = ', [276, 164, 180, 204, 172, 256, 260, 246, 288, 236, 236, 72, 104, 48, 8, 120, 48, 104, 172, 180, 56, 32, 124, 156, 204, 270, 228, 180, 204, 284, 140, 140, 188, 104, 56, 56, 104, 104, 40, 56, 40, 40, 56, 32, 8, 40, 32, 88, 56, 44, 104, 236, 40, 132, 40, 72, 32, 16, 72, 56, 32, 164, 236, 260, 128, 156, 212, 280, 172, 172, 260, 260, 236, 236, 148, 148, 284, 196, 236, 56, 196, 228, 288, 204, 236, 228, 236, 260, 48, 8, 172, 188, 228, 104, 80, 124, 104, 220, 148, 140, 104, 56, 32, 132, 220, 228, 220, 280, 284, 228, 260, 268, 260, 8, 32, 24, 80, 56, 124, 124, 64, 156, 172, 228, 228, 196, 228, 228, 236, 180, 172, 164, 172, 104, 64, 180, 180, 228, 276, 260, 180, 104, 80, 40, 228, 252, 180, 180, 228, 156, 188, 48, 56, 40, 124, 148, 172, 40, 228, 284, 40, 44, 132, 104, 132, 116, 116, 164, 252, 284, 90, 44, 40, 32, 24, 80, 32, 24, 16, 32, 196, 276, 252, 162, 180, 236, 56, 124, 72, 56, 172, 172, 172, 228, 180, 180, 92, 16, 32, 256, 212, 124, 124, 44, 56, 32, 124, 124, 132, 32, 56, 104, 80, 48, 32, 56, 56, 124, 104, 32, 64, 8, 8, 16, 136, 228, 260, 104, 56, 32, 16, 104, 172, 104, 40, 124, 212, 124, 172, 172, 172, 236, 212, 64, 104, 32, 276, 104, 56, 24, 140, 148, 188, 288, 246, 124, 276, 276, 132, 124, 8, 8, 260, 56, 284, 180, 40, 228, 104, 180, 236, 56, 196, 220, 124, 8, 276, 284, 276, 260])
('y1 = ', [85, 137, 37, 109, 109, 157, 61, 141, 129, 69, 93, 49, 121, 99, 81, 9, 73, 33, 45, 69, 89, 89, 117, 169, 145, 133, 169, 85, 57, 53, 137, 169, 169, 161, 97, 145, 105, 129, 63, 49, 153, 161, 121, 137, 109, 137, 65, 49, 33, 11, 41, 29, 121, 61, 73, 9, 17, 97, 41, 57, 121, 145, 85, 85, 9, 25, 65, 133, 61, 77, 69, 109, 169, 145, 169, 145, 93, 145, 37, 153, 161, 117, 109, 169, 77, 109, 61, 129, 63, 89, 125, 93, 37, 25, 25, 85, 81, 125, 85, 65, 137, 73, 57, 81, 73, 45, 145, 109, 85, 145, 93, 97, 45, 65, 97, 89, 25, 65, 125, 145, 157, 137, 169, 125, 29, 49, 85, 161, 101, 53, 53, 81, 37, 17, 21, 109, 93, 101, 93, 29, 61, 113, 157, 169, 93, 101, 101, 117, 69, 145, 145, 83, 81, 129, 101, 137, 117, 99, 77, 101, 113, 35, 169, 89, 145, 145, 161, 169, 125, 77, 165, 27, 51, 161, 45, 41, 145, 25, 25, 81, 101, 85, 21, 9, 45, 45, 41, 45, 25, 25, 21, 93, 101, 53, 21, 29, 9, 17, 73, 141, 169, 37, 21, 43, 105, 49, 53, 61, 137, 169, 129, 73, 9, 51, 153, 9, 137, 69, 97, 129, 41, 57, 41, 109, 9, 21, 37, 57, 113, 41, 57, 153, 145, 169, 145, 93, 117, 77, 29, 85, 69, 21, 145, 165, 49, 25, 77, 65, 17, 17, 145, 9, 41, 149, 157, 29, 61, 101, 21, 109, 97, 73, 53, 161, 69, 125, 83, 61, 145, 77, 53, 169, 169, 169, 169, 49, 69, 61, 53, 77])
In [ ]:
In [ ]: