如何用python求图中最短路

使用Python求图中最短路径的方法有：Dijkstra算法、Bellman-Ford算法、Floyd-Warshall算法。 其中，Dijkstra算法以其高效性和适用性广泛而被广泛使用。本文将详细介绍如何使用Dijkstra算法求图中最短路径。

一、DIJKSTRA算法

Dijkstra算法是一种贪心算法，用于解决从一个顶点到图中所有其他顶点的最短路径问题。它适用于权重为非负的图。以下是Dijkstra算法的详细步骤：

初始化：从起点开始，将起点到自己的距离设为0，其他顶点的距离设为无穷大。创建一个优先级队列，起点入队。
选择最短路径顶点：从队列中选择距离最近的顶点，作为当前顶点。
更新邻居顶点的距离：对当前顶点的每一个邻居顶点，计算从当前顶点经过该邻居顶点的路径长度。如果小于已知的最短路径，则更新最短路径。
重复步骤2和3：直到优先级队列为空。

import heapq
def dijkstra(graph, start):
    # 初始化
    pq = [(0, start)]  # (距离, 节点)
    distances = {node: float('infinity') for node in graph}
    distances[start] = 0
    visited = set()
    while pq:
        current_distance, current_node = heapq.heappop(pq)
        # 如果当前节点已经访问过，跳过
        if current_node in visited:
            continue
        visited.add(current_node)
        # 更新邻居节点的距离
        for neighbor, weight in graph[current_node].items():
            distance = current_distance + weight
            if distance < distances[neighbor]:
                distances[neighbor] = distance
                heapq.heappush(pq, (distance, neighbor))
    return distances
示例图
graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'C': 2, 'D': 5},
    'C': {'A': 4, 'B': 2, 'D': 1},
    'D': {'B': 5, 'C': 1}
}
print(dijkstra(graph, 'A'))

Dijkstra算法的核心在于贪心选择最近的顶点，并通过优先级队列优化选择过程。 这种方法保证了每次选择的顶点都是当前未处理顶点中距离起点最近的。

二、BELLMAN-FORD算法

Bellman-Ford算法用于解决从一个顶点到所有其他顶点的最短路径问题，特别适用于图中包含负权边的情况。其核心思想是通过不断松弛边来逐步找到最短路径。

初始化：设定起点到自己的距离为0，其他顶点距离为无穷大。
松弛边：重复V-1次（V是顶点数量），对于每一条边(u, v, w)，如果dist[u] + w < dist[v]，则更新dist[v]。
检测负权环：再进行一次松弛，如果还能更新距离，说明存在负权环。

def bellman_ford(graph, start):
    distances = {node: float('infinity') for node in graph}
    distances[start] = 0
    for _ in range(len(graph) - 1):
        for node in graph:
            for neighbor, weight in graph[node].items():
                if distances[node] + weight < distances[neighbor]:
                    distances[neighbor] = distances[node] + weight
    # 检测负权环
    for node in graph:
        for neighbor, weight in graph[node].items():
            if distances[node] + weight < distances[neighbor]:
                raise ValueError("Graph contains a negative-weight cycle")
    return distances
示例图
graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'C': 2, 'D': 5},
    'C': {'A': 4, 'B': 2, 'D': 1},
    'D': {'B': 5, 'C': 1}
}
print(bellman_ford(graph, 'A'))

Bellman-Ford算法的优点在于能够处理负权边，并且可以检测负权环。 然而，其时间复杂度较高，为O(VE)，不适合边很多的稠密图。

三、FLOYD-WARSHALL算法

Floyd-Warshall算法是一种动态规划算法，用于求解所有顶点对之间的最短路径。它适用于稠密图，且能够处理负权边，但不适用于负权环。

初始化：创建一个距离矩阵dist，dist[i][j]表示顶点i到顶点j的距离。直接相连的顶点距离为边权重，其他为无穷大。
动态规划：对于每一对顶点(i, j)，尝试通过一个中间顶点k，更新dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])。

def floyd_warshall(graph):
    nodes = list(graph.keys())
    dist = {node: {node: float('infinity') for node in nodes} for node in nodes}
    for node in nodes:
        dist[node][node] = 0
        for neighbor, weight in graph[node].items():
            dist[node][neighbor] = weight
    for k in nodes:
        for i in nodes:
            for j in nodes:
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
    return dist
示例图
graph = {
    'A': {'B': 1, 'C': 4},
    'B': {'A': 1, 'C': 2, 'D': 5},
    'C': {'A': 4, 'B': 2, 'D': 1},
    'D': {'B': 5, 'C': 1}
}
print(floyd_warshall(graph))