{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['CHN144.tsp', 'eil101.tsp', 'eil76.tsp', 'GR96.tsp', 'PBK411.tsp', 'PR76.tsp', 'RBU737.tsp', 'ulysses16.tsp', 'ulysses8.tsp', 'XIT1083.tsp']\n" ] } ], "source": [ "import os\n", "import numpy as np\n", "import time\n", "import matplotlib.pyplot as plt\n", "import pandas as pd\n", "from tsp_algo import *\n", "\n", "# 获取tsp_data目录下所有tsp文件\n", "data_dir = \"C:/Users/Lenovo/Desktop/LEAD/\"\n", "data_dir2 = \"C:/Users/Lenovo/Desktop/LEAD/tsp_data/data/\"\n", "test_files = [f for f in os.listdir(data_dir2) if f.endswith('tsp')]\n", "print(test_files)\n", "\n", "# 定义评估函数\n", "def evaluate_tsp(tsp_func, distances):\n", " \"\"\"评估TSP算法的性能\"\"\"\n", " try:\n", " # 计时并执行TSP\n", " start_time = time.time()\n", " path = tsp_func(distances)\n", " end_time = time.time()\n", " execution_time = end_time - start_time\n", " \n", " # 计算路径长度\n", " total_distance = 0\n", " n = len(distances)\n", " for i in range(n):\n", " total_distance += distances[path[i]][path[(i+1)%n]]\n", " \n", " print(f\"执行时间:{execution_time:.4f}秒, 路径长度:{total_distance:.2f}\")\n", " return total_distance, execution_time\n", " \n", " except Exception as e:\n", " print(f\"评估过程出错: {str(e)}\")\n", " return float('inf'), float('inf')\n", "\n", "# 定义数据加载函数 \n", "def load_tsp_data(filename):\n", " \"\"\"读取TSP问题数据\"\"\"\n", " try:\n", " cities = []\n", " filepath = os.path.join(data_dir2, filename)\n", " with open(filepath, 'r') as f:\n", " reading_coords = False\n", " for line in f:\n", " if line.strip() == \"NODE_COORD_SECTION\":\n", " reading_coords = True\n", " continue\n", " if line.strip() == \"EOF\":\n", " break\n", " if reading_coords:\n", " parts = line.strip().split()\n", " if len(parts) == 3:\n", " x, y = float(parts[1]), float(parts[2])\n", " cities.append((x, y))\n", " \n", " # 计算距离矩阵\n", " n = len(cities)\n", " distances = np.zeros((n, n))\n", " for i in range(n):\n", " for j in range(n):\n", " if i != j:\n", " distances[i,j] = np.sqrt((cities[i][0] - cities[j][0])**2 + \n", " (cities[i][1] - cities[j][1])**2)\n", " \n", " return distances\n", " \n", " except Exception as e:\n", " print(f\"读取数据出错: {str(e)}\")\n", " return None" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "测试实例: CHN144.tsp\n", "\n", "使用算法: 贪心算法\n", "执行时间:0.0027秒, 路径长度:35884.30\n", "\n", "使用算法: 最近邻算法\n", "执行时间:0.0025秒, 路径长度:35884.30\n", "\n", "使用算法: 插入法\n", "执行时间:0.3583秒, 路径长度:35048.39\n", "\n", "使用算法: EoH-TSP\n", "执行时间:0.1682秒, 路径长度:35884.30\n", "\n", "使用算法: AAD-TSP\n", "执行时间:0.2880秒, 路径长度:33158.55\n", "\n", "测试实例: eil101.tsp\n", "\n", "使用算法: 贪心算法\n", "执行时间:0.0010秒, 路径长度:825.24\n", "\n", "使用算法: 最近邻算法\n", "执行时间:0.0010秒, 路径长度:825.24\n", "\n", "使用算法: 插入法\n", "执行时间:0.1078秒, 路径长度:702.96\n", "\n", "使用算法: EoH-TSP\n", "执行时间:0.0958秒, 路径长度:847.59\n", "\n", "使用算法: AAD-TSP\n", "执行时间:0.1752秒, 路径长度:687.45\n", "\n", "测试实例: eil76.tsp\n", "\n", "使用算法: 贪心算法\n", "执行时间:0.0010秒, 路径长度:711.99\n", "\n", "使用算法: 最近邻算法\n", "执行时间:0.0010秒, 路径长度:711.99\n", "\n", "使用算法: 插入法\n", "执行时间:0.0435秒, 路径长度:612.39\n", "\n", "使用算法: EoH-TSP\n", "执行时间:0.0683秒, 路径长度:669.24\n", "\n", "使用算法: AAD-TSP\n", "执行时间:0.1143秒, 路径长度:622.71\n", "\n", "测试实例: GR96.tsp\n", "\n", "使用算法: 贪心算法\n", "执行时间:0.0010秒, 路径长度:707.09\n", "\n", "使用算法: 最近邻算法\n", "执行时间:0.0020秒, 路径长度:707.09\n", "\n", "使用算法: 插入法\n", "执行时间:0.0917秒, 路径长度:651.44\n", "\n", "使用算法: EoH-TSP\n", "执行时间:0.0962秒, 路径长度:707.09\n", "\n", "使用算法: AAD-TSP\n", "执行时间:0.2169秒, 路径长度:623.53\n", "\n", "测试实例: PBK411.tsp\n", "\n", "使用算法: 贪心算法\n", "执行时间:0.0169秒, 路径长度:1838.48\n", "\n", "使用算法: 最近邻算法\n", "执行时间:0.0170秒, 路径长度:1838.48\n", "\n", "使用算法: 插入法\n", "执行时间:7.6995秒, 路径长度:1602.35\n", "\n", "使用算法: EoH-TSP\n", "执行时间:0.9340秒, 路径长度:1835.85\n", "\n", "使用算法: AAD-TSP\n", "执行时间:5.2911秒, 路径长度:1554.96\n", "\n", "测试实例: PR76.tsp\n", "\n", "使用算法: 贪心算法\n", "执行时间:0.0010秒, 路径长度:153461.92\n", "\n", "使用算法: 最近邻算法\n", "执行时间:0.0000秒, 路径长度:153461.92\n", "\n", "使用算法: 插入法\n", "执行时间:0.0439秒, 路径长度:125936.21\n", "\n", "使用算法: EoH-TSP\n", "执行时间:0.0671秒, 路径长度:145300.57\n", "\n", "使用算法: AAD-TSP\n", "执行时间:0.1271秒, 路径长度:111623.46\n", "\n", "测试实例: RBU737.tsp\n", "\n", "使用算法: 贪心算法\n", "执行时间:0.0544秒, 路径长度:4416.15\n", "\n", "使用算法: 最近邻算法\n", "执行时间:0.0544秒, 路径长度:4416.15\n", "\n", "使用算法: 插入法\n", "执行时间:44.8784秒, 路径长度:4097.20\n", "\n", "使用算法: EoH-TSP\n", "执行时间:2.6006秒, 路径长度:4436.28\n", "\n", "使用算法: AAD-TSP\n", "执行时间:29.6802秒, 路径长度:3870.50\n", "\n", "测试实例: ulysses16.tsp\n", "\n", "使用算法: 贪心算法\n", "执行时间:0.0000秒, 路径长度:104.73\n", "\n", "使用算法: 最近邻算法\n", "执行时间:0.0000秒, 路径长度:104.73\n", "\n", "使用算法: 插入法\n", "执行时间:0.0015秒, 路径长度:79.39\n", "\n", "使用算法: EoH-TSP\n", "执行时间:0.0131秒, 路径长度:83.79\n", "\n", "使用算法: AAD-TSP\n", "执行时间:0.0314秒, 路径长度:74.00\n", "\n", "测试实例: ulysses8.tsp\n", "\n", "使用算法: 贪心算法\n", "执行时间:0.0000秒, 路径长度:38.48\n", "\n", "使用算法: 最近邻算法\n", "执行时间:0.0000秒, 路径长度:38.48\n", "\n", "使用算法: 插入法\n", "执行时间:0.0000秒, 路径长度:37.83\n", "\n", "使用算法: EoH-TSP\n", "执行时间:0.0076秒, 路径长度:38.48\n", "\n", "使用算法: AAD-TSP\n", "执行时间:0.0216秒, 路径长度:37.83\n", "\n", "测试实例: XIT1083.tsp\n", "\n", "使用算法: 贪心算法\n", "执行时间:0.1163秒, 路径长度:4584.27\n", "\n", "使用算法: 最近邻算法\n", "执行时间:0.1150秒, 路径长度:4584.27\n", "\n", "使用算法: 插入法\n", "执行时间:146.8186秒, 路径长度:4328.99\n", "\n", "使用算法: EoH-TSP\n", "执行时间:5.4694秒, 路径长度:4673.87\n", "\n", "使用算法: AAD-TSP\n", "执行时间:89.6922秒, 路径长度:4051.52\n", "\n", "所有算法在各个实例上的表现:\n", "\n", "贪心算法:\n", " CHN144.tsp: 路径长度 = 35884.30\n", " eil101.tsp: 路径长度 = 825.24\n", " eil76.tsp: 路径长度 = 711.99\n", " GR96.tsp: 路径长度 = 707.09\n", " PBK411.tsp: 路径长度 = 1838.48\n", " PR76.tsp: 路径长度 = 153461.92\n", " RBU737.tsp: 路径长度 = 4416.15\n", " ulysses16.tsp: 路径长度 = 104.73\n", " ulysses8.tsp: 路径长度 = 38.48\n", " XIT1083.tsp: 路径长度 = 4584.27\n", " CHN144.tsp: 执行时间 = 0.0027秒\n", " eil101.tsp: 执行时间 = 0.0010秒\n", " eil76.tsp: 执行时间 = 0.0010秒\n", " GR96.tsp: 执行时间 = 0.0010秒\n", " PBK411.tsp: 执行时间 = 0.0169秒\n", " PR76.tsp: 执行时间 = 0.0010秒\n", " RBU737.tsp: 执行时间 = 0.0544秒\n", " ulysses16.tsp: 执行时间 = 0.0000秒\n", " ulysses8.tsp: 执行时间 = 0.0000秒\n", " XIT1083.tsp: 执行时间 = 0.1163秒\n", "\n", "最近邻算法:\n", " CHN144.tsp: 路径长度 = 35884.30\n", " eil101.tsp: 路径长度 = 825.24\n", " eil76.tsp: 路径长度 = 711.99\n", " GR96.tsp: 路径长度 = 707.09\n", " PBK411.tsp: 路径长度 = 1838.48\n", " PR76.tsp: 路径长度 = 153461.92\n", " RBU737.tsp: 路径长度 = 4416.15\n", " ulysses16.tsp: 路径长度 = 104.73\n", " ulysses8.tsp: 路径长度 = 38.48\n", " XIT1083.tsp: 路径长度 = 4584.27\n", " CHN144.tsp: 执行时间 = 0.0025秒\n", " eil101.tsp: 执行时间 = 0.0010秒\n", " eil76.tsp: 执行时间 = 0.0010秒\n", " GR96.tsp: 执行时间 = 0.0020秒\n", " PBK411.tsp: 执行时间 = 0.0170秒\n", " PR76.tsp: 执行时间 = 0.0000秒\n", " RBU737.tsp: 执行时间 = 0.0544秒\n", " ulysses16.tsp: 执行时间 = 0.0000秒\n", " ulysses8.tsp: 执行时间 = 0.0000秒\n", " XIT1083.tsp: 执行时间 = 0.1150秒\n", "\n", "插入法:\n", " CHN144.tsp: 路径长度 = 35048.39\n", " eil101.tsp: 路径长度 = 702.96\n", " eil76.tsp: 路径长度 = 612.39\n", " GR96.tsp: 路径长度 = 651.44\n", " PBK411.tsp: 路径长度 = 1602.35\n", " PR76.tsp: 路径长度 = 125936.21\n", " RBU737.tsp: 路径长度 = 4097.20\n", " ulysses16.tsp: 路径长度 = 79.39\n", " ulysses8.tsp: 路径长度 = 37.83\n", " XIT1083.tsp: 路径长度 = 4328.99\n", " CHN144.tsp: 执行时间 = 0.3583秒\n", " eil101.tsp: 执行时间 = 0.1078秒\n", " eil76.tsp: 执行时间 = 0.0435秒\n", " GR96.tsp: 执行时间 = 0.0917秒\n", " PBK411.tsp: 执行时间 = 7.6995秒\n", " PR76.tsp: 执行时间 = 0.0439秒\n", " RBU737.tsp: 执行时间 = 44.8784秒\n", " ulysses16.tsp: 执行时间 = 0.0015秒\n", " ulysses8.tsp: 执行时间 = 0.0000秒\n", " XIT1083.tsp: 执行时间 = 146.8186秒\n", "\n", "EoH-TSP:\n", " CHN144.tsp: 路径长度 = 35884.30\n", " eil101.tsp: 路径长度 = 847.59\n", " eil76.tsp: 路径长度 = 669.24\n", " GR96.tsp: 路径长度 = 707.09\n", " PBK411.tsp: 路径长度 = 1835.85\n", " PR76.tsp: 路径长度 = 145300.57\n", " RBU737.tsp: 路径长度 = 4436.28\n", " ulysses16.tsp: 路径长度 = 83.79\n", " ulysses8.tsp: 路径长度 = 38.48\n", " XIT1083.tsp: 路径长度 = 4673.87\n", " CHN144.tsp: 执行时间 = 0.1682秒\n", " eil101.tsp: 执行时间 = 0.0958秒\n", " eil76.tsp: 执行时间 = 0.0683秒\n", " GR96.tsp: 执行时间 = 0.0962秒\n", " PBK411.tsp: 执行时间 = 0.9340秒\n", " PR76.tsp: 执行时间 = 0.0671秒\n", " RBU737.tsp: 执行时间 = 2.6006秒\n", " ulysses16.tsp: 执行时间 = 0.0131秒\n", " ulysses8.tsp: 执行时间 = 0.0076秒\n", " XIT1083.tsp: 执行时间 = 5.4694秒\n", "\n", "AAD-TSP:\n", " CHN144.tsp: 路径长度 = 33158.55\n", " eil101.tsp: 路径长度 = 687.45\n", " eil76.tsp: 路径长度 = 622.71\n", " GR96.tsp: 路径长度 = 623.53\n", " PBK411.tsp: 路径长度 = 1554.96\n", " PR76.tsp: 路径长度 = 111623.46\n", " RBU737.tsp: 路径长度 = 3870.50\n", " ulysses16.tsp: 路径长度 = 74.00\n", " ulysses8.tsp: 路径长度 = 37.83\n", " XIT1083.tsp: 路径长度 = 4051.52\n", " CHN144.tsp: 执行时间 = 0.2880秒\n", " eil101.tsp: 执行时间 = 0.1752秒\n", " eil76.tsp: 执行时间 = 0.1143秒\n", " GR96.tsp: 执行时间 = 0.2169秒\n", " PBK411.tsp: 执行时间 = 5.2911秒\n", " PR76.tsp: 执行时间 = 0.1271秒\n", " RBU737.tsp: 执行时间 = 29.6802秒\n", " ulysses16.tsp: 执行时间 = 0.0314秒\n", " ulysses8.tsp: 执行时间 = 0.0216秒\n", " XIT1083.tsp: 执行时间 = 89.6922秒\n", "\n", "各算法在不同实例上的路径长度:\n", " 贪心算法 最近邻算法 插入法 EoH-TSP AAD-TSP\n", "CHN144 35884.30 35884.30 35048.39 35884.30 33158.55\n", "eil101 825.24 825.24 702.96 847.59 687.45\n", "eil76 711.99 711.99 612.39 669.24 622.71\n", "GR96 707.09 707.09 651.44 707.09 623.53\n", "PBK411 1838.48 1838.48 1602.35 1835.85 1554.96\n", "PR76 153461.92 153461.92 125936.21 145300.57 111623.46\n", "RBU737 4416.15 4416.15 4097.20 4436.28 3870.50\n", "ulysses16 104.73 104.73 79.39 83.79 74.00\n", "ulysses8 38.48 38.48 37.83 38.48 37.83\n", "XIT1083 4584.27 4584.27 4328.99 4673.87 4051.52\n", "\n", "各算法在不同实例上的运行时长:\n", " 贪心算法 最近邻算法 插入法 EoH-TSP AAD-TSP\n", "CHN144 0.0027 0.0025 0.3583 0.1682 0.2880\n", "eil101 0.0010 0.0010 0.1078 0.0958 0.1752\n", "eil76 0.0010 0.0010 0.0435 0.0683 0.1143\n", "GR96 0.0010 0.0020 0.0917 0.0962 0.2169\n", "PBK411 0.0169 0.0170 7.6995 0.9340 5.2911\n", "PR76 0.0010 0.0000 0.0439 0.0671 0.1271\n", "RBU737 0.0544 0.0544 44.8784 2.6006 29.6802\n", "ulysses16 0.0000 0.0000 0.0015 0.0131 0.0314\n", "ulysses8 0.0000 0.0000 0.0000 0.0076 0.0216\n", "XIT1083 0.1163 0.1150 146.8186 5.4694 89.6922\n" ] } ], "source": [ "\n", "# 用于存储每个算法在每个实例上的结果 \n", "results = {}\n", "results_time = {}\n", "\n", "# 遍历每个测试实例\n", "for test_file in test_files:\n", " print(f\"\\n测试实例: {test_file}\")\n", " \n", " # 加载数据\n", " distances = load_tsp_data(test_file)\n", " if distances is None:\n", " continue\n", " \n", " # 这里可以添加多个待评估的TSP算法\n", " algorithms = {\n", " \"贪心算法\": greedy_tsp,\n", " \"最近邻算法\": nearest_neighbor_tsp,\n", " \"插入法\": insertion_tsp,\n", " # \"tsp_01\": tsp_01,\n", " \"EoH-TSP\": tsp_02,\n", " \"AAD-TSP\": tsp_04,\n", " }\n", " \n", " # 评估每个算法\n", " for alg_name, alg_func in algorithms.items():\n", " print(f\"\\n使用算法: {alg_name}\")\n", " score, etime = evaluate_tsp(alg_func, distances)\n", " \n", " if alg_name not in results:\n", " results[alg_name] = {}\n", " if alg_name not in results_time:\n", " results_time[alg_name] = {}\n", " results[alg_name][test_file] = score\n", " results_time[alg_name][test_file] = etime\n", "\n", "# 打印总结果\n", "print(\"\\n所有算法在各个实例上的表现:\")\n", "for alg_name, scores in results.items():\n", " print(f\"\\n{alg_name}:\")\n", " for test_file, score in scores.items():\n", " print(f\" {test_file}: 路径长度 = {score:.2f}\")\n", " for test_file, etime in results_time[alg_name].items():\n", " print(f\" {test_file}: 执行时间 = {etime:.4f}秒\")\n", "\n", "# 将结果整理成表格\n", "data = {}\n", "for test_file in test_files:\n", " instance_name = test_file.replace('.tsp', '')\n", " data[instance_name] = {}\n", " for alg_name in results:\n", " if test_file in results[alg_name]:\n", " data[instance_name][alg_name] = results[alg_name][test_file]\n", "\n", "# 将运行时间整理成表格\n", "data_time = {}\n", "for test_file in test_files:\n", " instance_name = test_file.replace('.tsp', '')\n", " data_time[instance_name] = {}\n", " for alg_name in results_time:\n", " if test_file in results_time[alg_name]:\n", " data_time[instance_name][alg_name] = results_time[alg_name][test_file]\n", "\n", "import random\n", "\n", "# 转换为DataFrame\n", "df_results = pd.DataFrame(data).T\n", "df_time = pd.DataFrame(data_time).T\n", "\n", "# 打印结果表格\n", "print(\"\\n各算法在不同实例上的路径长度:\")\n", "print(df_results.round(2)) # 路径长度保留2位小数\n", "# 统计每个算法的运行时长\n", "print(\"\\n各算法在不同实例上的运行时长:\")\n", "print(df_time.round(4)) # 运行时间保留4位小数\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "各算法在不同实例上的路径长度:\n", " 贪心算法 最近邻算法 插入法 EoH-TSP AAD-TSP\n", "ulysses8 38.48 38.48 37.83 38.48 37.83\n", "ulysses16 104.73 104.73 79.39 83.79 74.00\n", "eil76 711.99 711.99 612.39 669.24 622.71\n", "PR76 153461.92 153461.92 125936.21 145300.57 111623.46\n", "GR96 707.09 707.09 651.44 707.09 623.53\n", "eil101 825.24 825.24 702.96 847.59 687.45\n", "CHN144 35884.30 35884.30 35048.39 35884.30 33158.55\n", "PBK411 1838.48 1838.48 1602.35 1835.85 1554.96\n", "RBU737 4416.15 4416.15 4097.20 4436.28 3870.50\n", "XIT1083 4584.27 4584.27 4328.99 4673.87 4051.52\n", "\n", "各算法在不同实例上的运行时长:\n", " 贪心算法 最近邻算法 插入法 EoH-TSP AAD-TSP\n", "ulysses8 0.0000 0.0000 0.0000 0.0076 0.0216\n", "ulysses16 0.0000 0.0000 0.0015 0.0131 0.0314\n", "eil76 0.0010 0.0010 0.0435 0.0683 0.1143\n", "PR76 0.0010 0.0000 0.0439 0.0671 0.1271\n", "GR96 0.0010 0.0020 0.0917 0.0962 0.2169\n", "eil101 0.0010 0.0010 0.1078 0.0958 0.1752\n", "CHN144 0.0027 0.0025 0.3583 0.1682 0.2880\n", "PBK411 0.0169 0.0170 7.6995 0.9340 5.2911\n", "RBU737 0.0544 0.0544 44.8784 2.6006 29.6802\n", "XIT1083 0.1163 0.1150 146.8186 5.4694 89.6922\n" ] } ], "source": [ "# 创建排序用的临时索引\n", "temp_results_idx = pd.Index([int(''.join(filter(str.isdigit, idx))) for idx in df_results.index])\n", "temp_time_idx = pd.Index([int(''.join(filter(str.isdigit, idx))) for idx in df_time.index])\n", "\n", "# 按数字排序但保留原始名称\n", "df_results = df_results.iloc[temp_results_idx.argsort()]\n", "df_time = df_time.iloc[temp_time_idx.argsort()]\n", "\n", "# 打印结果表格\n", "print(\"\\n各算法在不同实例上的路径长度:\")\n", "print(df_results.round(2)) # 路径长度保留2位小数\n", "# 统计每个算法的运行时长 \n", "print(\"\\n各算法在不同实例上的运行时长:\")\n", "print(df_time.round(4)) # 运行时间保留4位小数" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# 提取EoH-TSP和AAD-TSP的运行时间数据\n", "selected_algos = ['EoH-TSP', 'AAD-TSP']\n", "df_selected = df_time[selected_algos]\n", "\n", "# 设置matplotlib支持中文显示\n", "plt.rcParams['font.sans-serif'] = ['SimHei'] # 用来正常显示中文标签\n", "plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号\n", "plt.rcParams['font.size'] = 16 # 设置更大的字号\n", "\n", "# 创建柱状图\n", "plt.figure(figsize=(12, 9))\n", "bar_width = 0.5\n", "x = np.arange(len(df_selected.index))\n", "\n", "# 绘制柱状图\n", "bars1 = plt.bar(x - bar_width/2, df_selected['EoH-TSP'], bar_width, label='AAD-TSP')\n", "bars2 = plt.bar(x + bar_width/2, df_selected['AAD-TSP'], bar_width, label='EoH-TSP')\n", "\n", "# 在柱形上添加数值标注\n", "for bars in [bars1, bars2]:\n", " for bar in bars:\n", " height = bar.get_height()\n", " plt.text(bar.get_x() + bar.get_width()/2., height,\n", " f'{height:.2f}',\n", " ha='center', va='bottom',fontsize=16)\n", "\n", "# 设置图表属性\n", "# plt.xlabel('测试实例')\n", "# plt.title('在不同实例上的运行时间')\n", "plt.xticks(x, df_selected.index, rotation=45,fontsize=20)\n", "plt.legend(fontsize=20)\n", "\n", "# 调整布局避免标签被截断\n", "plt.tight_layout()\n", "plt.savefig('tsp_time.png',dpi=300)\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "测试实例: CHN144.tsp\n", "\n", "使用算法: test\n", "执行时间:0.6112秒, 路径长度:33147.39\n", "\n", "测试实例: eil101.tsp\n", "\n", "使用算法: test\n", "执行时间:0.2688秒, 路径长度:693.38\n", "\n", "测试实例: eil76.tsp\n", "\n", "使用算法: test\n", "执行时间:0.1627秒, 路径长度:588.83\n", "\n", "测试实例: GR96.tsp\n", "\n", "使用算法: test\n", "执行时间:0.2340秒, 路径长度:629.57\n", "\n", "测试实例: PBK411.tsp\n", "\n", "使用算法: test\n", "执行时间:10.3389秒, 路径长度:1544.15\n", "\n", "测试实例: PR76.tsp\n", "\n", "使用算法: test\n", "执行时间:0.1454秒, 路径长度:120233.54\n", "\n", "测试实例: RBU737.tsp\n", "\n", "使用算法: test\n" ] }, { "ename": "KeyboardInterrupt", "evalue": "", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mKeyboardInterrupt\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[2]\u001b[39m\u001b[32m, line 22\u001b[39m\n\u001b[32m 20\u001b[39m \u001b[38;5;28;01mfor\u001b[39;00m algo_name, algo_func \u001b[38;5;129;01min\u001b[39;00m test_algo.items():\n\u001b[32m 21\u001b[39m \u001b[38;5;28mprint\u001b[39m(\u001b[33mf\u001b[39m\u001b[33m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[33m使用算法: \u001b[39m\u001b[38;5;132;01m{\u001b[39;00malgo_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[33m\"\u001b[39m)\n\u001b[32m---> \u001b[39m\u001b[32m22\u001b[39m path_length, exec_time = \u001b[43mevaluate_tsp\u001b[49m\u001b[43m(\u001b[49m\u001b[43malgo_func\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdist_matrix\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 24\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m algo_name \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m test_results:\n\u001b[32m 25\u001b[39m test_results[algo_name] = {}\n", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 20\u001b[39m, in \u001b[36mevaluate_tsp\u001b[39m\u001b[34m(tsp_func, distances)\u001b[39m\n\u001b[32m 17\u001b[39m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[32m 18\u001b[39m \u001b[38;5;66;03m# 计时并执行TSP\u001b[39;00m\n\u001b[32m 19\u001b[39m start_time = time.time()\n\u001b[32m---> \u001b[39m\u001b[32m20\u001b[39m path = \u001b[43mtsp_func\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdistances\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 21\u001b[39m end_time = time.time()\n\u001b[32m 22\u001b[39m execution_time = end_time - start_time\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Lenovo\\Desktop\\LEAD\\tsp_data\\tsp_algo.py:411\u001b[39m, in \u001b[36mtsp_05\u001b[39m\u001b[34m(distances)\u001b[39m\n\u001b[32m 408\u001b[39m temp *= cooling\n\u001b[32m 410\u001b[39m \u001b[38;5;66;03m# 2-opt局部优化\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m411\u001b[39m best_route = \u001b[43mtwo_opt\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbest_route\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdistances\u001b[49m\u001b[43m)\u001b[49m\n\u001b[32m 413\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m best_route\n", "\u001b[36mFile \u001b[39m\u001b[32mc:\\Users\\Lenovo\\Desktop\\LEAD\\tsp_data\\tsp_algo.py:277\u001b[39m, in \u001b[36mtwo_opt\u001b[39m\u001b[34m(route, distances)\u001b[39m\n\u001b[32m 273\u001b[39m old_dist = (distances[route[i-\u001b[32m1\u001b[39m]][route[i]] + \n\u001b[32m 274\u001b[39m distances[route[j-\u001b[32m1\u001b[39m]][route[j]])\n\u001b[32m 275\u001b[39m new_dist = (distances[route[i-\u001b[32m1\u001b[39m]][route[j-\u001b[32m1\u001b[39m]] + \n\u001b[32m 276\u001b[39m distances[route[i]][route[j]])\n\u001b[32m--> \u001b[39m\u001b[32m277\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m new_dist < old_dist:\n\u001b[32m 278\u001b[39m route[i:j] = \u001b[38;5;28mreversed\u001b[39m(route[i:j])\n\u001b[32m 279\u001b[39m improved = \u001b[38;5;28;01mTrue\u001b[39;00m\n", "\u001b[31mKeyboardInterrupt\u001b[39m: " ] } ], "source": [ "# 用于存储算法结果\n", "test_results = {}\n", "test_time = {}\n", "\n", "# 遍历测试实例\n", "for test_case in test_files:\n", " print(f\"\\n测试实例: {test_case}\")\n", " \n", " # 加载数据\n", " dist_matrix = load_tsp_data(test_case)\n", " if dist_matrix is None:\n", " continue\n", " \n", " # 仅测试单个算法\n", " test_algo = {\n", " \"test\": tsp_05 # 这里可以改成想测试的其他算法\n", " }\n", " \n", " # 评估算法\n", " for algo_name, algo_func in test_algo.items():\n", " print(f\"\\n使用算法: {algo_name}\")\n", " path_length, exec_time = evaluate_tsp(algo_func, dist_matrix)\n", " \n", " if algo_name not in test_results:\n", " test_results[algo_name] = {}\n", " if algo_name not in test_time:\n", " test_time[algo_name] = {}\n", " \n", " test_results[algo_name][test_case] = path_length\n", " test_time[algo_name][test_case] = exec_time\n", "\n", "# 打印结果\n", "print(\"\\n算法在各个实例上的表现:\")\n", "for algo_name, scores in test_results.items():\n", " print(f\"\\n{algo_name}:\")\n", " for test_case, score in scores.items():\n", " print(f\" {test_case}: 路径长度 = {score:.2f}\")\n", " for test_case, etime in test_time[algo_name].items():\n", " print(f\" {test_case}: 执行时间 = {etime:.4f}秒\")" ] } ], "metadata": { "kernelspec": { "display_name": "lead", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.11" } }, "nbformat": 4, "nbformat_minor": 2 }