Go语言实现最短路径算法（Shortest Path）

Go语言实现最短路径算法可以通过多种方式，其中常见的有Dijkstra算法和Bellman-Ford算法。下面是一个使用Dijkstra算法来计算最短路径的示例：

Dijkstra算法

Dijkstra算法是一种用于计算单源最短路径的经典算法，它适用于加权图，但不允许图中有负权边。以下是一个简单的Dijkstra算法实现：

package main

import (
	"container/heap"
	"fmt"
	"math"
)

// 定义一个图的数据结构
type Graph struct {
	vertices map[int]map[int]int
}

// 定义优先队列中的元素
type Item struct {
	vertex int
	dist   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].dist < pq[j].dist
}

func (pq PriorityQueue) Swap(i, j int) {
	pq[i], pq[j] = pq[j], pq[i]
	pq[i].index = i
	pq[j].index = j
}

func (pq *PriorityQueue) Push(x interface{}) {
	n := len(*pq)
	item := x.(*Item)
	item.index = n
	*pq = append(*pq, item)
}

func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	old[n-1] = nil  // 避免内存泄漏
	item.index = -1 // 用于安全性
	*pq = old[0 : n-1]
	return item
}

func (pq *PriorityQueue) update(item *Item, dist int) {
	item.dist = dist
	heap.Fix(pq, item.index)
}

func NewGraph() *Graph {
	return &Graph{vertices: make(map[int]map[int]int)}
}

func (g *Graph) AddEdge(u, v, weight int) {
	if g.vertices[u] == nil {
		g.vertices[u] = make(map[int]int)
	}
	g.vertices[u][v] = weight
	if g.vertices[v] == nil {
		g.vertices[v] = make(map[int]int)
	}
	g.vertices[v][u] = weight
}

func (g *Graph) Dijkstra(start int) map[int]int {
	dist := make(map[int]int)
	for vertex := range g.vertices {
		dist[vertex] = math.MaxInt64
	}
	dist[start] = 0

	pq := make(PriorityQueue, 1)
	pq[0] = &Item{vertex: start, dist: 0, index: 0}
	heap.Init(&pq)

	for pq.Len() > 0 {
		u := heap.Pop(&pq).(*Item).vertex

		for v, weight := range g.vertices[u] {
			if dist[u]+weight < dist[v] {
				dist[v] = dist[u] + weight
				heap.Push(&pq, &Item{vertex: v, dist: dist[v]})
			}
		}
	}

	return dist
}

func main() {
	graph := NewGraph()
	graph.AddEdge(0, 1, 4)
	graph.AddEdge(0, 2, 1)
	graph.AddEdge(2, 1, 2)
	graph.AddEdge(1, 3, 1)
	graph.AddEdge(2, 3, 5)

	dist := graph.Dijkstra(0)
	for vertex, d := range dist {
		fmt.Printf("Distance from 0 to %d is %d/n", vertex, d)
	}
}

代码说明

• Graph：图的数据结构，使用邻接表表示。
• Item：优先队列中的元素，包含顶点和距离。
• PriorityQueue：实现优先队列的必要方法。
• AddEdge：向图中添加边。
• Dijkstra：实现Dijkstra算法计算最短路径。
• main：主函数，创建图并计算从顶点0开始的最短路径。

这个实现使用Go语言标准库中的container/heap包来管理优先队列。优先队列中存储的是图的顶点和对应的距离。每次从队列中取出距离最小的顶点，并更新其邻接顶点的距离。