TSPDroneLIB 仓库包含了用于 TSP-D 和 FSTSP 的数据集和相关链接。该仓库提到了 Dataset - TSP-D Instances by Bouman et al. (2018) 的数据集，另外包括了 Bogyrbayeva 等（2023）使用的数据集。相关的算法可以在 TSPDrone.jl 仓库中找到。有关数据集的字段说明可以在 TSPDroneLIB/data/Bogyrbayeva/description.md 中找到。该数据集分类如下：

• Random：包含了三个不同节点数量大小的数据集，分别为 $n = 20, 50, 100$，每个数据集包含了 100 个算例，每行表示包含横纵坐标的一个算例，遵循格式 $x_1,y_1,x_2,y_2,\dots,x_n,y_n$，即每行的每两个数一组组成一个节点的横纵坐标，同时 $x_1,y_1$ 表示仓库节点的横纵坐标。该数据集的生成方法为：在 $[1100]\times[1100]$ 的范围内，从均匀分布中随机抽取每个节点的横纵坐标，唯一的例外是仓库节点，其位置分布在 $[0,1]\times[0,1]$ 范围内，这意味着仓库总是位于角落。这种数据集的生成方法和 Agatz 等（2018）使用的数据集生成方法是一致的。

• Amsterdam：该数据集的数据格式和 Random 数据集相同，共有四种不同大小的算例，分别为 $n = 10, 20, 50, 100$。该数据集基于 Haider 等（2019）研究中使用的电动汽车（electric vehicle, EV）停车位置数据集。这些位置反映了潜在顾客的位置，因为电动汽车通常停放在城市街道的路边充电器旁。为了适 Bogyrbayeva 等（2023）的研究，该文章从整个 Amsterdam 数据集中随机选取仓库和客户节点来创建不同的问题算例。

TSPDrone.jl 仓库中实现的 DPS 算法和 DRL 算法

TSPDrone.jl 仓库如前所述，解决了单车辆配备单架无人机的 TSP-D，实现了 Bogyrbayeva 等（2023）提出的 Divide-Partition-and-Search (DPS) 算法和 Deep Reinforcement Learning (DRL) 算法，其中 DPS 算法是基于 Agatz 等（2018）的 TSP-ep-all 算法和 Poikonen 等（2019）的 divide-and-conquer 启发式算法开发的。

DPS 算法是 Bogyrbayeva 等（2023）提出的一种基于分治策略的启发式算法，用于解决 TSP-D。其核心思想是将大规模问题分解为较小的子问题，并通过组合子问题的解来获得全局解。DPS 算法的主要步骤如下：

1. Divide：将全部节点划分为多个子组，每个子组包含固定数量（由参数 $g$ 控制）的节点。例如，$g = 10$ 表示每个子组有 10 个节点。

2. Partition & Search：在每个子组内，采用 TSP-ep-all 算法进行分区。TSP-ep-all 算法通过如下步骤优化子组内的路径：

   1. 生成初始 TSP 路径：使用 Concorde TSP Solver 得到卡车单独服务的初始路径。

   2. 动态规划分区：将路径中的节点划分为由卡车和无人机协同服务的子集，以最小化总时间。

   3. 局部搜索优化：进一步调整分区以提升解的质量。

3. 合并与全局优化：将所有子组的解合并为完整的路径，并进行全局优化（如调整子组边界或路径顺序）以消除局部最优的局限性。

在 DPS 算法中，较大的子组 $g$（如 $g = 25$）会提升解的质量，但增加计算时间；较小的子组 $g$（如 $g = 10$）则相反。当 $g = N$（总节点数）时，DPS 退化为直接应用 TSP-ep-all 算法，不再划分子组。

TSPDrone.jl 用 Julia 实现，初始 TSP 路径由 Concorde TSP Solver 生成，分区过程基于动态规划和局部搜索，使用该仓库 DPS 算法的步骤如下：

学习 Julia 的课程参考 MIT 的 Introduction to Computational Thinking

1. 安装 Julia，在命令行中输入 julia 进入 Julia 环境，输入命令安装必要的依赖：

   1] add https://github.com/chkwon/TSPDrone.jl
   

2. 使用 DPS 算法需要提供顾客节点的 $x$ 和 $y$ 坐标，仓库的 $(x, y)$ 坐标需要是第一个元素，参数 truck_cost_factor 和参数 drone_cost_factor 分别代表卡车和无人机的成本因子，会乘以从横纵坐标中计算出来的欧氏距离来得到卡车和无人机的行驶成本。

   1using TSPDrone
   2n = 10 
   3x = rand(n); y = rand(n);
   4truck_cost_factor = 1.0 
   5drone_cost_factor = 0.5
   6result = solve_tspd(x, y, truck_cost_factor, drone_cost_factor)
   7@show result.total_cost;
   8@show result.truck_route;
   9@show result.drone_route;
   

   如果正常运行，会输出如下结果（根据随机数生成的结果可能会有所不同），其中节点 11 作为终止节点表示仓库节点（即终止节点的代号会在总的节点数量上 +1）：

   1result.total_cost = 1.6022013835206805
   2result.truck_route = [1, 4, 5, 2, 8, 6, 11]
   3result.drone_route = [1, 9, 4, 10, 5, 7, 8, 3, 11]
   

3. 或者也可以直接提供卡车和无人机的成本矩阵（即原本根据欧氏距离矩阵乘以成本因子得到的矩阵），同样，仓库节点被标记为节点 1：

   1using TSPDrone
   2n = 10 
   3dist_mtx = rand(n, n)
   4dist_mtx = dist_mtx + dist_mtx' # symmetric distance only
   5truck_cost_mtx = dist_mtx .* 1.0
   6drone_cost_mtx = truck_cost_mtx .* 0.5 
   7result = solve_tspd(truck_cost_mtx, drone_cost_mtx)
   8@assert size(truck_cost_mtx) == size(drone_cost_mtx) == (n, n)
   

4. 使用命令 print_summary(result) 可以输出结果总结：

    1julia> print_summary(result)
    2Operation #1:
    3  - Truck        = 0.17988883875173492 : [1, 3]
    4  - Drone        = 0.11900891950265155 : [1, 4, 3]
    5  - Length       = 0.17988883875173492
    6Operation #2:
    7  - Truck        = 0.4784476248243221 : [3, 9]
    8  - Drone        = 0.27587675362585756 : [3, 7, 9]
    9  - Length       = 0.4784476248243221
   10Operation #3:
   11  - Truck        = 0.445749847855226 : [9, 6]
   12  - Drone        = 0.48831605249544785 : [9, 10, 6]
   13  - Length       = 0.48831605249544785
   14Operation #4:
   15  - Truck        = 0.9269158918021541 : [6, 5, 8, 11]
   16  - Drone        = 0.8714473929102112 : [6, 2, 11]
   17  - Length       = 0.9269158918021541
   18Total Cost = 2.073568407873659
   

5. 函数 solve_tspd 的可选参数包括：

   1n_groups::Int = 1, 
   2method::String = "TSP-ep-all", 
   3flying_range::Float64 = MAX_DRONE_RANGE, 
   4time_limit::Float64 = MAX_TIME_LIMIT
   

   • n_groups：用于分治法的子组数量。例如，如果 $n = 100$ 且 n_groups = 4，则每组将有 25 个节点，然后将方法 method 应用于每个组。

   • method：可以是以下的几种方法之一，TSP-ep 及其衍生方法（TSP-ep-1p、TSP-ep-2p、TSP-ep-2opt 和 TSP-ep-all）是基于 route-first，cluster-second 框架的启发式算法，由 Agatz 等（2018）提出，用于解决 TSP-D：

     • TSP-ep (Exact Partition)：使用 TSP 求解器（如 Concorde）生成最优 TSP 路径，然后以初始 TSP 路径为基础，通过精确划分算法（动态规划，时间复杂度为 $O(n^3)$）将 TSP 路径分割为卡车和无人机的协同路径。

     • TSP-ep-1p：在 TSP-ep 的基础上，引入单点移动邻域搜索（One-Point Move），通过调整单个节点的位置优化路径。即先对初始路径进行 Exact Partition，然后遍历每个节点，尝试将其移动到路径中的其他位置，计算目标函数改进，然后接受最大的移动，迭代直至无法进一步优化。

     • TSP-ep-2p：在 TSP-ep 的基础上，引入两点交换邻域搜索（Two-Point Swap），通过交换两个节点的位置优化路径。即先对初始路径进行 Exact Partition，然后遍历所有节点对，尝试交换两者的位置，计算目标函数改进，然后接受最大的交换，迭代直至无法进一步优化。

     • TSP-ep-2opt：在 TSP-ep 的基础上，引入 2-opt 邻域搜索，通过反转路径中的子段优化路径。即先对初始路径进行 Exact Partition，然后遍历所有可能的路径子段，尝试反转子段并重新计算总时间，接受改进最大的反转操作，迭代直至无法进一步优化。

     • TSP-ep-all：在 TSP-ep 的基础上，综合应用所有邻域搜索策略（1p、2p、2opt），通过多策略组合优化路径。即先对初始路径进行 Exact Partition，然后在每轮迭代中，尝试所有邻域操作（One-Point Move, Two-Point Swap, 2-opt），选择改进最大的操作，迭代直至无法进一步优化（表现最佳，但运行时间较长 $O(n^5)$）。

   • flying_range：无人机的飞行范围，默认值为 Inf。飞行范围与无人机成本矩阵中的值进行比较，即 drone_cost_mtx 或欧氏距离乘以 drone_cost_factor。

   • time_limit：算法运行的总时间限制，以秒为单位。对于每个组，时间限制平均分配。例如，如果 time_limit = 3600.0 且 n_groups = 5，则每组的时间限制为 $3600/5=720$ 秒。

TSP-D-Instances 仓库包含了用于 TSP-D 的二维数据集，即只有仓库和顾客节点的横纵坐标。在数据集中以符号/*开始，以符号*/结束的行是注释行，在读取数据时需要忽略。该数据集包含了 Agatz 等（2018）和 Bouman 等（2018）所用的数据集。相关的解决代码（Java 实现）可以在 Drones-TSP 仓库中找到。在这个数据集中，两点之间的距离是欧几里得距离（Euclidean distance），即两点之间的距离是两点之间的直线距离。有关数据集字段说明可以参考数据集的注释和 数据集仓库的说明。该数据集分类如下（在所有的情况中，生成的第一个节点位置被选作仓库节点）：

• uniform：每个节点的 $x$ 和 $y$ 坐标都是从取值范围为 $\{0,1,\dots,100\}$ 的独立均匀分布中随机生成的。

• singlecenter：对于每个位置，首先均匀地从区间 $[0,2\pi]$ 中抽取一个角度 $\alpha$，然后从一个均值为 0，标准差为 50 的正态分布中抽取一个距离 $r$，坐标 $(x,y)=(r\cdot \cos \alpha,r\cdot \sin\alpha)$，用这种方法生成的节点位置更有可能集中在中心点 $(0,0)$ 附近，比 uniform 的数据集更能模拟圆形城市中心的情况。

• doublecenter：生成方式和 singlecenter 类似，但在生成每个位置后，有 50% 的概率将其沿 $x$ 轴平移 200 个距离单位，这种方法生成的节点位置更有可能集中在两个中心点 $(0,0)$ 和 $(200,0)$ 附近，模拟了一个具有两个中心的城市的情况。

• restricted：在原有限制的基础上增加了一些额外的限制。

  • maxradius：增加了无人机不能飞行超过一定半径的限制。

  • novisit：增加了无人机不能访问的顾客节点，比如以 -novisit-20-rep_2.txt 为后缀的文件表示有 20% 的顾客节点被随机选中用于表示无法被无人机访问的顾客节点，由于对于同一个数据来说，不同次数的随机生成会影响选中的顾客节点，因此 rep_2 表示第二次随机生成的数据。具体的不能被无人机访问的顾客节点由字段 #NOVISIT 表示，例如数据文件中的 #NOVISIT 1 表示第一个顾客节点不能被无人机访问，也即生成的节点数据中的第二行数据（因为默认生成的第一行数据是仓库节点）。

tsp95.pdf 的内容如下：

Amazon Delivery Dataset 是一个 Amazon 公司最后一公里物流运营情况的数据集，包含了超过 43632 次配送的多城市数据，数据字段包括订单详情、配送人员、天气、交通情况、配送仓库和配送地点的经纬度等信息。要将数据集转换为可以用于 TSP-D 的数据集，需要将数据集中的经纬度转换为欧几里得距离，即两点之间的直线距离，当然在此之前需要对原始数据集进行一些数据的预处理工作。

数据预处理

关于已知两点经纬度计算两点之间距离的方法，这里使用了 Haversine formula ，但是要注意这个公式只是一个近似值，即假设地球是一个球体，而实际上地球是一个椭球体，不过对于不是精确到亚米级别的应用来说，这个公式的精度是足够的，误差在 $0.5\%$ 以内。如果需要更精确的方法可以参考 Vincenty’s formulae 和 Geographical distance。根据经纬度判断这个点是否在陆地的方法可以参考 Python 的库 global-land-mask。

在代码中使用的不是 $\arcsin$ 而是 $\arctan$，这是因为当 $\sin$ 值接近 1 时，直接使用 $\arcsin$ 可能导致精度问题，而 $\arctan$ 通过显式分离分子分母，可以使得计算更加稳定。$\arcsin$ 和 $\arctan$ 之间的转换可以参考 实用反三角函数运算公式。

 1import pandas as pd
 2from math import radians, sin, cos, sqrt, atan2
 3from global_land_mask import globe
 4
 5# Haversine公式计算距离
 6def haversine(lat1, lon1, lat2, lon2):
 7    R = 6371.393 # 地球半径近似值
 8    lat1_rad, lon1_rad = radians(lat1), radians(lon1)
 9    lat2_rad, lon2_rad = radians(lat2), radians(lon2)
10    dlon = lon2_rad - lon1_rad
11    dlat = lat2_rad - lat1_rad
12    a = sin(dlat/2)**2 + cos(lat1_rad)*cos(lat2_rad)*sin(dlon/2)**2
13    return R * 2 * atan2(sqrt(a), sqrt(1-a))
14
15# 读取数据
16df = pd.read_csv('amazon_delivery.csv')
17
18# 步骤1: 筛选顾客节点>=10的仓库
19valid_warehouses = df.groupby(['Store_Latitude', 'Store_Longitude']).filter(lambda x: len(x) >= 10)
20
21# 步骤2: 剔除顾客-仓库经纬度差>=1的订单
22valid_warehouses = valid_warehouses[
23    (abs(valid_warehouses['Store_Latitude'] - valid_warehouses['Drop_Latitude']) < 1) &
24    (abs(valid_warehouses['Store_Longitude'] - valid_warehouses['Drop_Longitude']) < 1)
25]
26
27# 步骤3: 计算距离并筛选<=50公里的订单
28valid_warehouses['Distance'] = valid_warehouses.apply(
29    lambda row: haversine(row['Store_Latitude'], row['Store_Longitude'],
30                          row['Drop_Latitude'], row['Drop_Longitude']),
31    axis=1
32)
33valid_warehouses = valid_warehouses[valid_warehouses['Distance'] <= 50]
34
35# 步骤4: 去重同一仓库下的重复顾客
36valid_warehouses = valid_warehouses.drop_duplicates(
37    subset=['Store_Latitude', 'Store_Longitude', 'Drop_Latitude', 'Drop_Longitude']
38)
39
40# 步骤5: 检查仓库是否在陆地
41# 提取唯一仓库坐标
42warehouse_coords = valid_warehouses[['Store_Latitude', 'Store_Longitude']].drop_duplicates()
43
44# 使用global_land_mask检查陆地
45warehouse_coords['Is_Land'] = warehouse_coords.apply(
46    lambda row: globe.is_land(row['Store_Latitude'], row['Store_Longitude']),
47    axis=1
48)
49
50# 合并陆地标记到原始数据
51valid_warehouses = valid_warehouses.merge(
52    warehouse_coords[['Store_Latitude', 'Store_Longitude', 'Is_Land']],
53    on=['Store_Latitude', 'Store_Longitude'],
54    how='left'
55)
56
57# 步骤6: 剔除位于海里的仓库数据
58final_data = valid_warehouses[valid_warehouses['Is_Land']]
59
60# 输出结果
61final_data.to_excel('amazon_delivery_filtered_data.xlsx', index=False)
62warehouse_stats = final_data.groupby(['Store_Latitude', 'Store_Longitude']).size().reset_index(name='Count')
63warehouse_stats.sort_values(by='Count', ascending=False).to_excel('warehouse_stats.xlsx', index=False)

首先删除不需要的数据列。接着通过将前面得到的数据导入到 Google Maps 中，可以看到仓库数据大致可以聚类成 22 个簇，因此聚类时设置聚类数量为 22。然后将同一聚类的仓库节点和配送节点合并到同一个 Excel 文件中，因此总共会生成 22 个不同聚类的 Excel 文件。

 1import pandas as pd
 2import numpy as np
 3from sklearn.cluster import KMeans
 4import os
 5
 6# 1. 读取Excel文件并提取需要的列
 7df = pd.read_excel("amazon_delivery_filtered_data.xlsx")
 8filtered_df = df[["Store_Latitude", "Store_Longitude", "Drop_Latitude", "Drop_Longitude"]]
 9
10# 2. 提取唯一的仓库坐标用于聚类
11store_coords = filtered_df[["Store_Latitude", "Store_Longitude"]].drop_duplicates()
12
13# 3. 使用KMeans进行聚类（已知聚类数=22）
14kmeans = KMeans(n_clusters=22, random_state=42, n_init=10)
15store_coords["Cluster"] = kmeans.fit_predict(store_coords[["Store_Latitude", "Store_Longitude"]])
16
17# 4. 将聚类标签合并回原始数据
18merged_df = filtered_df.merge(
19    store_coords,
20    how="left",
21    on=["Store_Latitude", "Store_Longitude"]
22)
23
24# 5. 创建保存结果的文件夹
25output_dir = "clustered_nodes"
26os.makedirs(output_dir, exist_ok=True)
27
28# 6. 按聚类分组处理数据
29for cluster_id in range(22):
30    # 提取当前聚类的数据
31    cluster_data = merged_df[merged_df["Cluster"] == cluster_id]
32    
33    # 分离仓库节点和顾客节点
34    store_nodes = cluster_data[["Store_Latitude", "Store_Longitude"]].drop_duplicates()
35    customer_nodes = cluster_data[["Drop_Latitude", "Drop_Longitude"]].drop_duplicates()
36    
37    # 生成唯一ID
38    store_nodes["ID"] = ["store_" + str(i) for i in range(len(store_nodes))]
39    customer_nodes["ID"] = ["customer_" + str(i) for i in range(len(customer_nodes))]
40    
41    # 重命名列以匹配
42    store_nodes.rename(columns={"Store_Latitude": "latitude", "Store_Longitude": "longitude"}, inplace=True)
43    customer_nodes.rename(columns={"Drop_Latitude": "latitude", "Drop_Longitude": "longitude"}, inplace=True)
44    
45    # 合并节点并整理列顺序
46    combined_nodes = pd.concat([store_nodes, customer_nodes], ignore_index=True)
47    combined_nodes = combined_nodes[["ID", "latitude", "longitude"]]
48    
49    # 输出每个聚类的节点数量
50    total_nodes = len(store_nodes) + len(customer_nodes)
51    print(f"聚类 {cluster_id} 有 {total_nodes} 个节点（仓库节点: {len(store_nodes)}，顾客节点: {len(customer_nodes)}）")
52    
53    # 保存到Excel文件
54    output_path = os.path.join(output_dir, f"cluster_{cluster_id}.xlsx")
55    combined_nodes.to_excel(output_path, index=False)