414 lines
13 KiB
Python
414 lines
13 KiB
Python
|
import numpy as np
|
||
|
|
from typing import List
|
||
|
|
|
||
|
|
def greedy_tsp(distances: np.ndarray) -> List[int]:
|
||
|
|
"""贪心算法求解TSP
|
||
|
|
|
||
|
|
Args:
|
||
|
|
distances: 距离矩阵
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
访问顺序列表
|
||
|
|
"""
|
||
|
|
n = len(distances)
|
||
|
|
unvisited = set(range(1, n)) # 未访问的城市集合
|
||
|
|
path = [0] # 从城市0开始
|
||
|
|
|
||
|
|
while unvisited:
|
||
|
|
last = path[-1]
|
||
|
|
# 找到距离最后一个城市最近的未访问城市
|
||
|
|
next_city = min(unvisited, key=lambda x: distances[last][x])
|
||
|
|
path.append(next_city)
|
||
|
|
unvisited.remove(next_city)
|
||
|
|
|
||
|
|
return path
|
||
|
|
|
||
|
|
def nearest_neighbor_tsp(distances: np.ndarray) -> List[int]:
|
||
|
|
"""最近邻算法求解TSP
|
||
|
|
|
||
|
|
Args:
|
||
|
|
distances: 距离矩阵
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
访问顺序列表
|
||
|
|
"""
|
||
|
|
n = len(distances)
|
||
|
|
unvisited = set(range(1, n))
|
||
|
|
path = [0] # 从城市0开始
|
||
|
|
|
||
|
|
while unvisited:
|
||
|
|
curr = path[-1]
|
||
|
|
# 找到距离当前城市最近的未访问城市
|
||
|
|
next_city = min(unvisited, key=lambda x: distances[curr][x])
|
||
|
|
path.append(next_city)
|
||
|
|
unvisited.remove(next_city)
|
||
|
|
|
||
|
|
return path
|
||
|
|
|
||
|
|
def insertion_tsp(distances: np.ndarray) -> List[int]:
|
||
|
|
"""插入法求解TSP
|
||
|
|
|
||
|
|
Args:
|
||
|
|
distances: 距离矩阵
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
访问顺序列表
|
||
|
|
"""
|
||
|
|
n = len(distances)
|
||
|
|
# 初始化包含前两个城市的回路
|
||
|
|
path = [0, np.argmin(distances[0][1:])+1]
|
||
|
|
unvisited = set(range(1, n)) - {path[1]}
|
||
|
|
|
||
|
|
while unvisited:
|
||
|
|
min_increase = float('inf')
|
||
|
|
best_pos = -1
|
||
|
|
best_city = -1
|
||
|
|
|
||
|
|
# 尝试将每个未访问城市插入到当前路径的每个可能位置
|
||
|
|
for city in unvisited:
|
||
|
|
for i in range(len(path)):
|
||
|
|
j = (i + 1) % len(path)
|
||
|
|
# 计算插入后的路径增量
|
||
|
|
increase = (distances[path[i]][city] +
|
||
|
|
distances[city][path[j]] -
|
||
|
|
distances[path[i]][path[j]])
|
||
|
|
if increase < min_increase:
|
||
|
|
min_increase = increase
|
||
|
|
best_pos = i + 1
|
||
|
|
best_city = city
|
||
|
|
|
||
|
|
# 将最佳城市插入到最佳位置
|
||
|
|
path.insert(best_pos, best_city)
|
||
|
|
unvisited.remove(best_city)
|
||
|
|
|
||
|
|
return path
|
||
|
|
|
||
|
|
def tsp_01(distances: np.ndarray) -> List[int]:
|
||
|
|
"""动态规划+2-opt优化求解TSP(内存优化版)
|
||
|
|
|
||
|
|
Args:
|
||
|
|
distances: 距离矩阵
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
访问顺序列表
|
||
|
|
"""
|
||
|
|
from itertools import combinations
|
||
|
|
from typing import List
|
||
|
|
import numpy as np
|
||
|
|
|
||
|
|
n = len(distances)
|
||
|
|
# 使用字典存储dp表,只保存必要的状态
|
||
|
|
dp = {}
|
||
|
|
dp[(1, 0)] = 0
|
||
|
|
|
||
|
|
# 动态规划部分,使用位运算加速
|
||
|
|
for size in range(2, n + 1):
|
||
|
|
# 提前计算所有可能的子集
|
||
|
|
subsets = list(combinations(range(n), size))
|
||
|
|
for subset in subsets:
|
||
|
|
mask = sum(1 << i for i in subset)
|
||
|
|
for v in subset:
|
||
|
|
if v == 0:
|
||
|
|
continue
|
||
|
|
prev_mask = mask ^ (1 << v)
|
||
|
|
min_dist = float('inf')
|
||
|
|
# 只遍历必要的前驱节点
|
||
|
|
for u in subset:
|
||
|
|
if u != v and (prev_mask & (1 << u)):
|
||
|
|
curr_dist = dp.get((prev_mask, u), float('inf')) + distances[u][v]
|
||
|
|
min_dist = min(min_dist, curr_dist)
|
||
|
|
if min_dist != float('inf'):
|
||
|
|
dp[(mask, v)] = min_dist
|
||
|
|
|
||
|
|
# 重建路径,使用贪心策略
|
||
|
|
final_mask = (1 << n) - 1
|
||
|
|
last_city = min(range(1, n),
|
||
|
|
key=lambda u: dp.get((final_mask, u), float('inf')) + distances[u][0])
|
||
|
|
path = [0]
|
||
|
|
curr_mask = final_mask
|
||
|
|
curr_city = last_city
|
||
|
|
|
||
|
|
# 使用集合加速查找
|
||
|
|
remaining = set(range(n))
|
||
|
|
remaining.remove(0)
|
||
|
|
|
||
|
|
while remaining:
|
||
|
|
path.append(curr_city)
|
||
|
|
remaining.remove(curr_city)
|
||
|
|
prev_mask = curr_mask ^ (1 << curr_city)
|
||
|
|
curr_city = min(remaining,
|
||
|
|
key=lambda u: dp.get((prev_mask, u), float('inf')) + distances[u][curr_city])
|
||
|
|
curr_mask = prev_mask
|
||
|
|
|
||
|
|
path.append(curr_city)
|
||
|
|
|
||
|
|
# 优化版2-opt
|
||
|
|
improved = True
|
||
|
|
best_dist = float('inf')
|
||
|
|
while improved:
|
||
|
|
improved = False
|
||
|
|
curr_dist = sum(distances[path[i]][path[i+1]] for i in range(n-1)) + distances[path[-1]][path[0]]
|
||
|
|
if curr_dist < best_dist:
|
||
|
|
best_dist = curr_dist
|
||
|
|
for i in range(1, n-2):
|
||
|
|
for j in range(i+2, n):
|
||
|
|
delta = (distances[path[i-1]][path[j-1]] + distances[path[i]][path[j]] -
|
||
|
|
distances[path[i-1]][path[i]] - distances[path[j-1]][path[j]])
|
||
|
|
if delta < 0:
|
||
|
|
path[i:j] = reversed(path[i:j])
|
||
|
|
improved = True
|
||
|
|
break
|
||
|
|
if improved:
|
||
|
|
break
|
||
|
|
|
||
|
|
return path
|
||
|
|
|
||
|
|
def tsp_02(distances: np.ndarray) -> List[int]:
|
||
|
|
"""动态规划+简化遗传算法求解TSP
|
||
|
|
|
||
|
|
Args:
|
||
|
|
distances: 距离矩阵
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
访问顺序列表
|
||
|
|
"""
|
||
|
|
from typing import List
|
||
|
|
import numpy as np
|
||
|
|
import random
|
||
|
|
|
||
|
|
n = len(distances)
|
||
|
|
# 使用贪心算法生成初始解
|
||
|
|
path = list(range(n))
|
||
|
|
for i in range(n-1):
|
||
|
|
min_j = min(range(i+1, n),
|
||
|
|
key=lambda j: distances[path[i]][path[j]])
|
||
|
|
path[i+1], path[min_j] = path[min_j], path[i+1]
|
||
|
|
|
||
|
|
# 简化的遗传算法
|
||
|
|
pop_size = 20 # 减小种群大小
|
||
|
|
generations = 100 # 减少迭代次数
|
||
|
|
population = [path[:]]
|
||
|
|
|
||
|
|
# 生成初始种群
|
||
|
|
for _ in range(pop_size - 1):
|
||
|
|
new_path = path[:]
|
||
|
|
i, j = random.sample(range(1, n), 2)
|
||
|
|
new_path[i], new_path[j] = new_path[j], new_path[i]
|
||
|
|
population.append(new_path)
|
||
|
|
|
||
|
|
for _ in range(generations):
|
||
|
|
# 选择最优的一半
|
||
|
|
population.sort(key=lambda x: sum(distances[x[i]][x[i+1]]
|
||
|
|
for i in range(n-1)) + distances[x[-1]][x[0]])
|
||
|
|
population = population[:pop_size//2]
|
||
|
|
|
||
|
|
# 通过交叉生成新解
|
||
|
|
while len(population) < pop_size:
|
||
|
|
p1, p2 = random.sample(population, 2)
|
||
|
|
cut = random.randint(1, n-2)
|
||
|
|
child = p1[:cut]
|
||
|
|
child.extend(x for x in p2 if x not in child)
|
||
|
|
population.append(child)
|
||
|
|
|
||
|
|
return min(population,
|
||
|
|
key=lambda x: sum(distances[x[i]][x[i+1]]
|
||
|
|
for i in range(n-1)) + distances[x[-1]][x[0]])
|
||
|
|
|
||
|
|
def tsp_03(distances: np.ndarray) -> List[int]:
|
||
|
|
"""快速模拟退火求解TSP
|
||
|
|
|
||
|
|
Args:
|
||
|
|
distances: 距离矩阵
|
||
|
|
|
||
|
|
Returns:
|
||
|
|
访问顺序列表
|
||
|
|
"""
|
||
|
|
from typing import List
|
||
|
|
import numpy as np
|
||
|
|
import random
|
||
|
|
import math
|
||
|
|
|
||
|
|
n = len(distances)
|
||
|
|
# 使用贪心算法生成初始解
|
||
|
|
route = list(range(n))
|
||
|
|
for i in range(n-1):
|
||
|
|
min_j = min(range(i+1, n),
|
||
|
|
key=lambda j: distances[route[i]][route[j]])
|
||
|
|
route[i+1], route[min_j] = route[min_j], route[i+1]
|
||
|
|
|
||
|
|
current_cost = sum(distances[route[i]][route[i+1]]
|
||
|
|
for i in range(n-1)) + distances[route[-1]][route[0]]
|
||
|
|
|
||
|
|
# 快速降温的模拟退火
|
||
|
|
temp = 100.0
|
||
|
|
cooling = 0.95
|
||
|
|
iterations = 50 # 减少迭代次数
|
||
|
|
|
||
|
|
while temp > 0.1:
|
||
|
|
for _ in range(iterations):
|
||
|
|
i, j = random.sample(range(1, n), 2)
|
||
|
|
new_route = route[:]
|
||
|
|
new_route[i], new_route[j] = new_route[j], new_route[i]
|
||
|
|
|
||
|
|
new_cost = sum(distances[new_route[k]][new_route[k+1]]
|
||
|
|
for k in range(n-1)) + distances[new_route[-1]][new_route[0]]
|
||
|
|
|
||
|
|
if new_cost < current_cost or random.random() < math.exp((current_cost - new_cost) / temp):
|
||
|
|
route = new_route
|
||
|
|
current_cost = new_cost
|
||
|
|
|
||
|
|
temp *= cooling
|
||
|
|
|
||
|
|
return route
|
||
|
|
|
||
|
|
def two_opt(route, distances):
|
||
|
|
"""简化版2-opt优化"""
|
||
|
|
improved = True
|
||
|
|
while improved:
|
||
|
|
improved = False
|
||
|
|
for i in range(1, len(route) - 2):
|
||
|
|
if improved:
|
||
|
|
break
|
||
|
|
for j in range(i + 2, len(route)):
|
||
|
|
old_dist = (distances[route[i-1]][route[i]] +
|
||
|
|
distances[route[j-1]][route[j]])
|
||
|
|
new_dist = (distances[route[i-1]][route[j-1]] +
|
||
|
|
distances[route[i]][route[j]])
|
||
|
|
if new_dist < old_dist:
|
||
|
|
route[i:j] = reversed(route[i:j])
|
||
|
|
improved = True
|
||
|
|
break
|
||
|
|
return route
|
||
|
|
|
||
|
|
def calculate_cost(route, distances):
|
||
|
|
"""计算路径总成本"""
|
||
|
|
return sum(distances[route[i]][route[(i + 1) % len(route)]]
|
||
|
|
for i in range(len(route)))
|
||
|
|
|
||
|
|
def tsp_04(distances):
|
||
|
|
"""
|
||
|
|
高性能TSP求解算法,结合多种优化策略:
|
||
|
|
1. 贪心构造初始解
|
||
|
|
2. 快速模拟退火
|
||
|
|
3. 2-opt局部搜索
|
||
|
|
"""
|
||
|
|
import random
|
||
|
|
import math
|
||
|
|
n = len(distances)
|
||
|
|
|
||
|
|
# 贪心构造初始解
|
||
|
|
unvisited = set(range(1, n))
|
||
|
|
current = 0
|
||
|
|
route = [0]
|
||
|
|
while unvisited:
|
||
|
|
next_city = min(unvisited, key=lambda x: distances[current][x])
|
||
|
|
route.append(next_city)
|
||
|
|
unvisited.remove(next_city)
|
||
|
|
current = next_city
|
||
|
|
|
||
|
|
# 快速模拟退火
|
||
|
|
temp = 100.0
|
||
|
|
cooling = 0.95
|
||
|
|
iterations = 30
|
||
|
|
|
||
|
|
current_cost = calculate_cost(route, distances)
|
||
|
|
best_route = route[:]
|
||
|
|
best_cost = current_cost
|
||
|
|
|
||
|
|
while temp > 0.1:
|
||
|
|
for _ in range(iterations):
|
||
|
|
# 随机交换两个城市
|
||
|
|
i, j = random.sample(range(1, n), 2)
|
||
|
|
new_route = route[:]
|
||
|
|
new_route[i], new_route[j] = new_route[j], new_route[i]
|
||
|
|
|
||
|
|
new_cost = calculate_cost(new_route, distances)
|
||
|
|
|
||
|
|
if new_cost < current_cost or random.random() < math.exp((current_cost - new_cost) / temp):
|
||
|
|
route = new_route
|
||
|
|
current_cost = new_cost
|
||
|
|
if new_cost < best_cost:
|
||
|
|
best_route = new_route[:]
|
||
|
|
best_cost = new_cost
|
||
|
|
|
||
|
|
temp *= cooling
|
||
|
|
|
||
|
|
# 2-opt局部优化
|
||
|
|
best_route = two_opt(best_route, distances)
|
||
|
|
|
||
|
|
return best_route
|
||
|
|
|
||
|
|
def tsp_05(distances):
|
||
|
|
"""
|
||
|
|
基于插入法的TSP优化算法:
|
||
|
|
1. 插入法构造初始解
|
||
|
|
2. 快速模拟退火
|
||
|
|
3. 2-opt局部搜索
|
||
|
|
"""
|
||
|
|
import random
|
||
|
|
import math
|
||
|
|
n = len(distances)
|
||
|
|
|
||
|
|
# 插入法构造初始解
|
||
|
|
route = [0, 1] # 从城市0和1开始
|
||
|
|
unvisited = set(range(2, n))
|
||
|
|
|
||
|
|
while unvisited:
|
||
|
|
# 找到最佳插入位置和待插入城市
|
||
|
|
min_increase = float('inf')
|
||
|
|
best_pos = 0
|
||
|
|
best_city = 0
|
||
|
|
|
||
|
|
for city in unvisited:
|
||
|
|
# 尝试所有可能的插入位置
|
||
|
|
for i in range(len(route)):
|
||
|
|
if i == len(route) - 1:
|
||
|
|
increase = (distances[route[i]][city] +
|
||
|
|
distances[city][route[0]] -
|
||
|
|
distances[route[i]][route[0]])
|
||
|
|
else:
|
||
|
|
increase = (distances[route[i]][city] +
|
||
|
|
distances[city][route[i+1]] -
|
||
|
|
distances[route[i]][route[i+1]])
|
||
|
|
|
||
|
|
if increase < min_increase:
|
||
|
|
min_increase = increase
|
||
|
|
best_pos = i + 1
|
||
|
|
best_city = city
|
||
|
|
|
||
|
|
# 在最佳位置插入城市
|
||
|
|
route.insert(best_pos, best_city)
|
||
|
|
unvisited.remove(best_city)
|
||
|
|
|
||
|
|
# 快速模拟退火
|
||
|
|
temp = 100.0
|
||
|
|
cooling = 0.95
|
||
|
|
iterations = 30
|
||
|
|
|
||
|
|
current_cost = calculate_cost(route, distances)
|
||
|
|
best_route = route[:]
|
||
|
|
best_cost = current_cost
|
||
|
|
|
||
|
|
while temp > 0.1:
|
||
|
|
for _ in range(iterations):
|
||
|
|
# 随机交换两个城市
|
||
|
|
i, j = random.sample(range(1, n), 2)
|
||
|
|
new_route = route[:]
|
||
|
|
new_route[i], new_route[j] = new_route[j], new_route[i]
|
||
|
|
|
||
|
|
new_cost = calculate_cost(new_route, distances)
|
||
|
|
|
||
|
|
if new_cost < current_cost or random.random() < math.exp((current_cost - new_cost) / temp):
|
||
|
|
route = new_route
|
||
|
|
current_cost = new_cost
|
||
|
|
if new_cost < best_cost:
|
||
|
|
best_route = new_route[:]
|
||
|
|
best_cost = new_cost
|
||
|
|
|
||
|
|
temp *= cooling
|
||
|
|
|
||
|
|
# 2-opt局部优化
|
||
|
|
best_route = two_opt(best_route, distances)
|
||
|
|
|
||
|
|
return best_route
|