Dijkstra最短路径算法|贪婪的算法7

概述

Dijkstra算法是一种贪婪算法，用于在加权有向图或无向图中找到单个源点到所有其他顶点的最短路径，贪心策略是每次扩展距离最短的顶点，直到扩展到终点或无法扩展为止。该算法被广泛应用于路由算法和其他网络协议中。

算法步骤

1. 创建两个集合S和V-S，S中包含源点，V-S包含剩余的顶点，距离集合D初始化为源点到其他点的距离，前驱集合P记录每个顶点的前驱节点，初值为源点。

2. 找到集合V-S中距离最小的顶点u，并将其移入集合S中。

3. 对集合V-S中的每个顶点进行松弛操作，即如果通过u可以缩短到这些顶点的距离，则更新D和P。

4. 重复步骤2和3，直到集合V-S中的所有点都移入了S集合，算法结束。

伪代码

function Dijkstra(Graph, source):
    dist[source] := 0                     // 初始化源点到自身为0
    for each vertex v in Graph:           // 初始化所有节点距离为无穷大
        if v ≠ source
            dist[v] := infinity
        add v to Q                        // 加入未处理集合Q
    while Q is not empty:
        u := vertex in Q with min dist[u]  // 提取Q中距离最小的节点u
        remove u from Q
        for each neighbor v of u:          // 对u的所有邻居进行松弛操作
            alt := dist[u] + length(u, v)
            if alt < dist[v]              
                dist[v] := alt           // 更新距离
                prev[v] := u             // 更新前驱节点
    return dist[], prev[]

代码示例

以下是使用Python实现Dijkstra算法的示例代码：

import heapq

def dijkstra(graph, start):
    # 初始化距离集合和前驱集合
    dist = {v: float('inf') for v in graph}
    prev = {v: None for v in graph}
    dist[start] = 0
    
    # 将距离和顶点以元组的形式加入堆中，堆按距离排序
    heap = [(0, start)]
    while heap:
        # 弹出距离最小的顶点
        (d, current_vertex) = heapq.heappop(heap)
        # 如果已经处理，跳过
        if d > dist[current_vertex]:
            continue
        # 对邻居进行松弛操作
        for neighbor in graph[current_vertex]:
            distance = dist[current_vertex] + graph[current_vertex][neighbor]
            if distance < dist[neighbor]:
                dist[neighbor] = distance
                prev[neighbor] = current_vertex
                heapq.heappush(heap, (distance, neighbor))
    return dist, prev

时间复杂度

采用堆来实现Dijkstra算法的时间复杂度为O((E+V)logV)，其中V是顶点数，E是边数。具体推导过程请参考算法导论第三版9.3节。