Dijkstra算法实战：用Python实现地铁换乘最短路径规划

1. 引言：当算法遇见地铁

在日常通勤中，我们经常需要计算地铁换乘的最优路线。如何高效地找到耗时最短的路径？这正是经典图论算法Dijkstra的拿手好戏。本文将通过Python实现一个地铁换乘规划系统，带你深入理解算法原理与工程实践的完美结合。

2. 算法核心思想

Dijkstra算法由荷兰计算机科学家Edsger Dijkstra于1956年提出，其核心逻辑可以用一句话概括：

每次选择当前已知最短路径的节点，更新其邻居的最短距离

算法步骤解析：

1. 初始化起点距离为0，其他节点距离为无穷大
2. 使用优先队列存储待处理节点
3. 每次取出距离最小的节点
4. 遍历该节点的所有邻居，进行松弛操作
5. 重复直到队列为空

3. 地铁网络建模技巧

将地铁系统抽象为图结构需要特殊处理：

# 地铁线路示例数据结构
metro_system = {
    "lines": {
        "1号线": ["苹果园", "古城", "八角游乐园", "八宝山"],
        "2号线": ["西直门", "车公庄", "阜成门", "复兴门"],
        "4号线": ["安河桥北", "北宫门", "西苑", "圆明园"]
    },
    "transfers": {
        "复兴门": ["1号线", "2号线"],
        "西单": ["1号线", "4号线"]
    },
    "params": {
        "station_time": 3,  # 每站行驶时间（分钟）
        "transfer_time": 5  # 换乘时间（分钟）
    }
}

4. Python完整实现代码

4.1 构建地铁图结构

import heapq
from collections import defaultdict

def build_graph(metro):
    graph = defaultdict(dict)
    station_time = metro['params']['station_time']
    transfer_time = metro['params']['transfer_time']
  
    # 处理线路内站点连接
    for line, stations in metro['lines'].items():
        for i in range(len(stations)-1):
            s1 = f"{stations[i]}_{line}"
            s2 = f"{stations[i+1]}_{line}"
            graph[s1][s2] = station_time
            graph[s2][s1] = station_time
  
    # 处理换乘站连接
    for station in metro['transfers']:
        lines = metro['transfers'][station]
        for i in range(len(lines)):
            for j in range(i+1, len(lines)):
                s1 = f"{station}_{lines[i]}"
                s2 = f"{station}_{lines[j]}"
                graph[s1][s2] = transfer_time
                graph[s2][s1] = transfer_time
              
    return graph

4.2 Dijkstra算法实现

def dijkstra(graph, start, end):
    distances = {node: float('inf') for node in graph}
    distances[start] = 0
    previous = {}
    heap = [(0, start)]
  
    while heap:
        current_dist, current = heapq.heappop(heap)
      
        if current == end:
            break
          
        if current_dist > distances[current]:
            continue
          
        for neighbor, weight in graph[current].items():
            distance = current_dist + weight
            if distance < distances.get(neighbor, float('inf')):
                distances[neighbor] = distance
                previous[neighbor] = current
                heapq.heappush(heap, (distance, neighbor))
  
    return distances, previous

4.3 路径回溯与换乘识别

def get_path(previous, start, end):
    path = []
    current = end
  
    while current != start:
        path.append(current)
        current = previous.get(current)
        if not current:
            return None
  
    path.append(start)
    return path[::-1]

def parse_transfer(path):
    transfers = []
    current_line = path[0].split('_')[1]
  
    for station in path[1:]:
        name, line = station.split('_')
        if line != current_line:
            transfers.append(f"在{name}换乘{line}")
            current_line = line
  
    return transfers

5. 实战案例演示

metro = { ... }  # 前文定义的地铁系统

graph = build_graph(metro)
start = "苹果园_1号线"
end = "圆明园_4号线"

distances, previous = dijkstra(graph, start, end)
path = get_path(previous, start, end)
transfers = parse_transfer(path)

print(f"总耗时：{distances[end]}分钟")
print(" -> ".join([node.split('_')[0] for node in path]))
print("换乘提醒：")
print('\n'.join(transfers))

示例输出：

总耗时：27分钟
苹果园 -> 古城 -> 八角游乐园 -> 八宝山 -> 复兴门 -> 复兴门 -> 西单 -> 西单 -> 西苑 -> 圆明园
换乘提醒：
在复兴门换乘2号线
在西单换乘4号线

6. 性能优化方向

1. 双向Dijkstra搜索：同时从起点和终点进行搜索，相遇时终止
2. A*算法优化：引入启发式函数预估剩余距离
3. 预处理技术：利用Transit Node Routing等高级算法
4. 并行计算：多线程处理不同线路的查询

7. 总结与资源

本文实现的地铁换乘系统完整代码已上传GitHub：

https://github.com/metro-dijkstra/python-implementation

思考题：如果考虑不同时段的列车密度，如何修改权重计算方式？欢迎在评论区讨论！