Go语言实现最短路径算法：Dijkstra与Bellman-Ford详解

1. 最短路径算法概述

在计算机科学中，最短路径问题是一个经典的基础性问题，它要求在图结构中找到两个节点之间成本最低的路径。作为Go语言开发者，理解并实现这类算法对于构建高效的路由系统、物流规划等应用至关重要。

最短路径算法主要分为单源最短路径（从一个起点到所有其他节点）和全源最短路径（所有节点之间的最短路径）两大类。在Go语言中，我们可以利用其强大的并发特性和简洁的语法，高效实现这些算法。

2. 核心算法原理

2.1 Dijkstra算法

Dijkstra算法是解决单源最短路径问题的经典算法，适用于边权值为非负的图。它的核心思想是贪心策略，逐步扩展已知的最短路径集合。

算法步骤如下：

1. 初始化：设置起点距离为0，其他节点距离为无穷大
2. 选择当前距离最小的未处理节点
3. 对该节点的所有邻居进行松弛操作
4. 标记该节点为已处理
5. 重复步骤2-4直到所有节点都被处理

在Go中，我们可以使用优先队列（堆）来高效实现节点选择：

go复制type Item struct {
    node     int
    distance int
    index    int
}

type PriorityQueue []*Item

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool {
    return pq[i].distance < pq[j].distance
}

func (pq *PriorityQueue) Pop() interface{} {
    old := *pq
    n := len(old)
    item := old[n-1]
    *pq = old[0 : n-1]
    return item
}

2.2 Bellman-Ford算法

Bellman-Ford算法可以处理包含负权边的图，并能检测负权环。它的基本思想是通过对所有边进行V-1次松弛操作（V为节点数），逐步逼近最短路径。

算法特点：

• 时间复杂度O(VE)
• 能检测负权环
• 实现简单但效率较低

Go实现示例：

go复制func BellmanFord(graph [][]int, V, E, src int) ([]int, bool) {
    dist := make([]int, V)
    for i := range dist {
        dist[i] = math.MaxInt32
    }
    dist[src] = 0

    for i := 1; i < V; i++ {
        for j := 0; j < E; j++ {
            u := graph[j][0]
            v := graph[j][1]
            weight := graph[j][2]
            if dist[u] != math.MaxInt32 && dist[u]+weight < dist[v] {
                dist[v] = dist[u] + weight
            }
        }
    }

    // 检查负权环
    for j := 0; j < E; j++ {
        u := graph[j][0]
        v := graph[j][1]
        weight := graph[j][2]
        if dist[u] != math.MaxInt32 && dist[u]+weight < dist[v] {
            return nil, false
        }
    }

    return dist, true
}

2.3 Floyd-Warshall算法

Floyd-Warshall算法解决全源最短路径问题，适用于稠密图。它通过动态规划的思想，逐步构建所有节点对之间的最短路径。

算法特点：

• 时间复杂度O(V³)
• 可以处理负权边（但不能有负权环）
• 实现简洁但空间复杂度高

Go实现关键部分：

go复制func FloydWarshall(graph [][]int, V int) [][]int