一些有趣的最短路径问题

最短路径问题是图论中的一个经典问题，具有广泛的应用。本文将介绍一些有趣的最短路径问题，并给出代码实现。

1. 单源最短路径问题

单源最短路径问题，是指从图中的一个顶点出发，到达其它所有顶点的最短路径问题。常用的算法包括 Dijkstra 算法和 Bellman-Ford 算法。

Dijkstra 算法

Dijkstra 算法是一种贪心算法，通过不断扩展到目前为止的最短路径来求解最短路径问题。具体步骤如下：

1. 初始化所有节点的距离为无穷大，起点的距离为 0。
2. 从距离起点最近的节点开始扩展，更新其它节点的距离。
3. 重复步骤 2，直到所有节点都被扩展。

这个算法的时间复杂度为 $O(|V|^2)$，但是可以使用堆优化实现 $O(|E| \log |V|)$ 的时间复杂度。

import heapq

def dijkstra(adj, start):
    inf = float('inf')
    dist = [inf] * len(adj)
    dist[start] = 0
    heap = [(0, start)]
    while heap:
        d, u = heapq.heappop(heap)
        if d > dist[u]:
            continue
        for v, w in adj[u]:
            if dist[v] > dist[u] + w:
                dist[v] = dist[u] + w
                heapq.heappush(heap, (dist[v], v))
    return dist

Bellman-Ford 算法

Bellman-Ford 算法是一种动态规划算法，可以处理负权边。具体步骤如下：

1. 初始化所有节点的距离为无穷大，起点的距离为 0。
2. 重复 $|V|-1$ 次以下操作：
   1. 对于每条边 $(u,v,w)$，如果 $dist[u]+w<dist[v]$，则更新 $dist[v]=dist[u]+w$。
3. 检查是否存在负环路，即重复上述操作后，仍然存在 $dist[u]+w<dist[v]$ 的情况。

这个算法的时间复杂度为 $O(|V||E|)$，但是可以在 $O(|E|)$ 的时间内检查是否存在负环路。

def bellman_ford(adj, start):
    inf = float('inf')
    dist = [inf] * len(adj)
    dist[start] = 0
    for i in range(len(adj)-1):
        for u in range(len(adj)):
            for v, w in adj[u]:
                if dist[u]+w < dist[v]:
                    dist[v] = dist[u]+w
    for u in range(len(adj)):
        for v, w in adj[u]:
            if dist[u]+w < dist[v]:
                return None   # 存在负环路
    return dist

2. 多源最短路径问题

多源最短路径问题，是指求所有节点对之间的最短路径。Floyd-Warshall 算法是一种经典算法，可以处理负权边，时间复杂度为 $O(|V|^3)$。

def floyd_warshall(adj):
    inf = float('inf')
    dist = [[inf] * len(adj) for _ in range(len(adj))]
    for u in range(len(adj)):
        for v, w in adj[u]:
            dist[u][v] = w
    for k in range(len(adj)):
        for i in range(len(adj)):
            for j in range(len(adj)):
                if dist[i][k] < inf and dist[k][j] < inf:
                    dist[i][j] = min(dist[i][j], dist[i][k]+dist[k][j])
    return dist

3. 最短路径树问题

最短路径树问题，是指在一张带权无向图中，找出以某个节点为根节点的最短路径树。常用的算法包括 Prim 算法和 Kruskal 算法。

Prim 算法

Prim 算法是一种贪心算法，通过逐步扩展最小生成树来求解最短路径树问题。具体步骤如下：

1. 随意选定一个节点作为起点，设为已访问节点。
2. 从已访问节点到未访问节点的所有边中，选取权值最小的边，设其连接的未访问节点为下一个已访问节点。
3. 重复步骤 2，直到所有节点都被访问。

这个算法的时间复杂度为 $O(|V|^2)$，但是可以使用堆优化实现 $O(|E| \log |V|)$ 的时间复杂度。

import heapq

def prim(adj, start):
    inf = float('inf')
    dist = [inf] * len(adj)
    dist[start] = 0
    heap = [(0, start)]
    used = [False] * len(adj)
    while heap:
        d, u = heapq.heappop(heap)
        if used[u]:
            continue
        used[u] = True
        for v, w in adj[u]:
            if not used[v] and w < dist[v]:
                dist[v] = w
                heapq.heappush(heap, (dist[v], v))
    return dist

Kruskal 算法

Kruskal 算法是一种贪心算法，通过逐步加入边，构建最小生成树来求解最短路径树问题。具体步骤如下：

1. 把每个节点看作一个连通子图。
2. 把所有边按权值排序，从小到大依次考虑每条边。
3. 如果这条边连接的两个节点不在同一个连通子图中，则将它们合并为一个连通子图，并把这条边加入最小生成树。
4. 重复步骤 3，直到最小生成树已经包含 $|V|-1$ 条边。

这个算法的时间复杂度为 $O(|E| \log |E|)$，可以使用并查集来优化实现。

def kruskal(edges):
    def find(x):
        if parent[x] != x:
            parent[x] = find(parent[x])
        return parent[x]
    edges.sort(key=lambda x: x[2])
    parent = [i for i in range(len(adj))]
    mst = []
    for u, v, w in edges:
        root_u, root_v = find(u), find(v)
        if root_u != root_v:
            parent[root_u] = root_v
            mst.append((u, v, w))
            if len(mst) == len(adj)-1:
                break
    return mst

总结

本文介绍了一些有趣的最短路径问题，包括单源最短路径问题、多源最短路径问题和最短路径树问题。相应的算法有 Dijkstra 算法、Bellman-Ford 算法、Floyd-Warshall 算法、Prim 算法和 Kruskal 算法。代码实现中，可以使用堆优化、动态规划和并查集等数据结构和算法进行优化。