TSP旅行商问题（Traveling Salesman Problem）

最新推荐文章于 2024-09-24 12:08:16 发布

RRRRRoyal

最新推荐文章于 2024-09-24 12:08:16 发布

阅读量6.3k

点赞数 31

文章标签：性能优化启发式算法人工智能 python

本文链接：https://blog.youkuaiyun.com/m0_73916791/article/details/134737864

版权

在这里插入图片描述

TSP旅行商问题（Traveling Salesman Problem）

基本情况

TSP问题是组合优化中最著名的问题之一。给定一组城市和每对城市之间的距离，旅行商问题问的是：旅行商从某一个城市出发，必须访问每个城市一次，最后回到原始城市，这样的最短可能行程是什么？

TSP问题的难点

组合性：可能的行程数量随着城市数量的增加而阶乘级增加。
NP难性：没有多项式时间复杂度的已知算法可以解决TSP问题。

解决基本思想

尽管TSP问题是NP-hard的，有几种基本思想可以用于近似或推断TSP问题的解，包括：

暴力解法：尝试所有可能的组合来找出最短路径。
动态规划：通过存储并重用子问题的解决方案来求解。
贪心算法：在每一步选择当前最短的边接下来的城市。
启发式算法：
- 最近邻方法（Nearest Neighbor）：选择下一个最近未访问的城市。
- 最小生成树（Minimum Spanning Tree）：基于创建一个覆盖所有城市的最小生成树。
- 遗传算法（Genetic Algorithms）：模拟自然选择的概念，通过混合路径并选择表现良好的解。
- 模拟退火（Simulated Annealing）：通过概率性的移动，允许解决方案临时变得更差以跳出局部最优。

经典TSP问题

问题一：简单边权TSP

问题描述

给定一组城市和每对城市之间的距离，求解最短循环行程。

解题思路

使用暴力解法，尝试所有的排列组合找出最短的一个。

Python代码示例

from itertools import permutations
import sys

# 距离矩阵
distances = [
    [0, 10, 15, 20],
    [10, 0, 35, 25],
    [15, 35, 0, 30],
    [20, 25, 30, 0]
]

# 暴力解法计算最佳路径
def tsp_bruteforce(distances):
    n = len(distances)
    perm = permutations(range(n))
    min_path = maxsize = sys.maxsize
    for p in perm:
        current_pathweight = 0
        # 计算当前排列的路径长度
        for i in range(n):
            current_pathweight += distances[p[i % n]][p[(i + 1) % n]]
        min_path = min(min_path, current_pathweight)
    return min_path

print(tsp_bruteforce(distances))

问题二：最近邻居TSP

问题描述

仿照真实情况，在不知道所有城市的情况下，旅行商从一个城市出发，每次都访问最近的未访问城市，直到所有城市都被访问过。

解题思路

从任意一个城市开始，每次选择与当前城市距离最近的未访问城市作为下一个目的地。

Python代码示例

# 计算最近邻居旅行路径
def tsp_nearest_neighbor(distances, starting=0):
    n = len(distances)
    visited = [False] * n
    path_length = 0
    path = [starting]
    visited[starting] = True
    
    # 遍历所有的城市
    for _ in range(n - 1):
        last = path[-1]
        next_city = min([(city, dist) for city, dist in enumerate(distances[last]) if not visited[city]], key=lambda x: x[1])
        path_length += next_city[1]
        path.append(next_city[0])
        visited[next_city[0]] = True
    # 返回到起始城市
    path_length += distances[path[-1]][starting]
    return path_length, path

print(tsp_nearest_neighbor(distances))

问题三：模拟退火TSP

问题描述

给定一组城市和每对城市之间的距离矩阵，找出近似的最短路径。

解题思路

使用模拟退火算法，在每一步都尝试交换两个城市的顺序，如果新顺序提供更短的路径则接受它，如果路径稍长也有一定概率接受它，以此来避免局部最优。

Python代码示例

import math
import random

# 计算路径长度
def path_length(distances, path):
    length = sum(distances[path[i]][path[i+1]] for i in range(-1, len(path)-1))
    return length

# 模拟退火算法进行旅行商问题求解
def tsp_simulated_annealing(distances, temp=10000, cooling_rate=0.003, stop_temp=1):
    n = len(distances)
    # 初始化为随机路径
    current_solution = list(range(n))
    random.shuffle(current_solution)
    current_path_length = path_length(distances, current_solution)
    best_solution = list(current_solution)
    best_path_length = current_path_length

    while temp > stop_temp:
        # 交换两个城市的顺序
        i, j = sorted(random.sample(range(n), 2))
        new_solution = current_solution[:i] + current_solution[j:j+1] + \
                       current_solution[i+1:j] + current_solution[i:i+1] + \
                       current_solution[j+1:]
        new_path_length = path_length(distances, new_solution)
        # 如果新路径更短或在概率下接受更长的路径
        if new_path_length < current_path_length or random.random() < \
           math.exp((current_path_length - new_path_length) / temp):
            current_solution = new_solution
            current_path_length = new_path_length
            # 更新最佳解
            if current_path_length < best_path_length:
                best_solution = current_solution
                best_path_length = current_path_length
        temp *= 1 - cooling_rate
    return best_path_length, best_solution

print(tsp_simulated_annealing(distances))