二、在 Johnson 算法里，在集合 V 中加入新结点 s 产生 V’ 的目的是什么？如果要写代码，请用go语言。

chatgpt：

在 Johnson 算法中，向集合 V 中添加的新节点 ( s ) 的目的主要是为了处理图中的负权边。因为 Johnson 算法用于计算有向图中所有顶点对之间的最短路径，而负权边可能导致 Dijkstra 算法无法正确工作（Dijkstra 算法假设所有边的权重都是非负的）。

具体来说，Johnson 算法通过构造一个辅助图，在这个辅助图中新增一个节点 ( s )，并且将 ( s ) 与图中所有其他节点之间的边权重设为0。这个新节点的引入确保了图中的所有节点都能通过这个新节点进行路径扩展，从而生成一个没有负权边的图，使得后续的 Dijkstra 算法能够成功运行。

这里是用 Go 语言实现 Johnson 算法的一个简化版本的代码示例：

package main

import (
	"fmt"
	"math"
)

type Edge struct {
	from, to, weight int
}

func bellmanFord(edges []Edge, V, start int) ([]int, bool) {
	distance := make([]int, V)
	for i := range distance {
		distance[i] = math.MaxInt32
	}
	distance[start] = 0

	for i := 0; i < V-1; i++ {
		for _, edge := range edges {
			if distance[edge.from] != math.MaxInt32 && distance[edge.from]+edge.weight < distance[edge.to] {
				distance[edge.to] = distance[edge.from] + edge.weight
			}
		}
	}

	for _, edge := range edges {
		if distance[edge.from] != math.MaxInt32 && distance[edge.from]+edge.weight < distance[edge.to] {
			return nil, true // 发现负权回路
		}
	}

	return distance, false
}

func dijkstra(graph [][]int, start int) []int {
	V := len(graph)
	dist := make([]int, V)
	visited := make([]bool, V)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[start] = 0

	for i := 0; i < V; i++ {
		minIndex := -1
		for j := 0; j < V; j++ {
			if !visited[j] && (minIndex == -1 || dist[j] < dist[minIndex]) {
				minIndex = j
			}
		}

		if dist[minIndex] == math.MaxInt32 {
			break
		}

		visited[minIndex] = true
		for v, weight := range graph[minIndex] {
			if weight != math.MaxInt32 && dist[minIndex]+weight < dist[v] {
				dist[v] = dist[minIndex] + weight
			}
		}
	}

	return dist
}

func johnson(graph [][]int) ([][]int, bool) {
	V := len(graph)
	edges := []Edge{}

	for u := 0; u < V; u++ {
		for v, weight := range graph[u] {
			if weight != math.MaxInt32 {
				edges = append(edges, Edge{from: u, to: v, weight: weight})
			}
		}
	}

	// 添加一个新节点 s
	for i := 0; i < V; i++ {
		edges = append(edges, Edge{from: V, to: i, weight: 0})
	}

	dist, hasNegativeCycle := bellmanFord(edges, V+1, V)

	if hasNegativeCycle {
		return nil, true
	}

	// 重新标记边权
	for i := 0; i < V; i++ {
		for j := 0; j < V; j++ {
			if graph[i][j] != math.MaxInt32 {
				graph[i][j] += dist[i] - dist[j]
			}
		}
	}

	// 最终结果
	result := make([][]int, V)
	for i := range result {
		result[i] = dijkstra(graph, i)
	}

	return result, false
}

func main() {
	// 示例图，使用无穷大代表没有边
	graph := [][]int{
		{0, 3, math.MaxInt32, 5},
		{math.MaxInt32, 0, 2, math.MaxInt32},
		{math.MaxInt32, math.MaxInt32, 0, 1},
		{math.MaxInt32, math.MaxInt32, 3, 0},
	}

	shortestPaths, hasNegativeCycle := johnson(graph)
	if hasNegativeCycle {
		fmt.Println("图中存在负权回路")
	} else {
		for i, distances := range shortestPaths {
			fmt.Printf("从节点 %d 到其他节点的最短路径: %v\n", i, distances)
		}
	}
}

在这个代码示例中，我们定义了基本的数据结构和必要的函数，包括 Bellman-Ford 算法用于检测负权回路和 Dijkstra 算法用于计算最短路径。我们在 Johnson 算法中通过增加节点 ( s ) 并给出合适的边权来处理图的权重，然后调用 Dijkstra 算法来计算最终的最短路径。

deepseek：

在Johnson算法中，向原图集合V中添加新结点s的目的是为了通过Bellman-Ford算法计算每个节点的势能（h值），从而重新调整边权，消除负权重，使得后续可以使用Dijkstra算法高效计算所有节点对的最短路径。

详细步骤解释：

1. 引入虚拟结点s：连接s到所有原图结点，边权为0。
2. Bellman-Ford检测负环：以s为源点运行Bellman-Ford算法，若存在负环则终止。
3. 计算势能h值：Bellman-Ford得到s到各结点的最短距离作为h值。
4. 调整边权：对原图每条边(u→v)，新权重为w + h[u] - h[v]（确保非负）。
5. Dijkstra计算最短路径：调整权重后，对每个结点运行Dijkstra算法。
6. 还原路径权重：将调整后的路径权重还原为原始权重。

Go语言实现代码：

package main

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

type Edge struct {
	to     int
	weight int
}

type PriorityQueue []*Node

type Node struct {
	id   int
	dist int
}

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] }

func (pq *PriorityQueue) Push(x interface{}) {
	*pq = append(*pq, x.(*Node))
}

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

func bellmanFord(n int, adj [][]Edge, s int) ([]int, bool) {
	dist := make([]int, n+1)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[s] = 0

	for i := 0; i < n; i++ {
		updated := false
		for u := 0; u <= n; u++ {
			if dist[u] == math.MaxInt32 {
				continue
			}
			for _, e := range adj[u] {
				if dist[e.to] > dist[u]+e.weight {
					dist[e.to] = dist[u] + e.weight
					updated = true
				}
			}
		}
		if !updated {
			break
		}
	}

	for u := 0; u <= n; u++ {
		if dist[u] == math.MaxInt32 {
			continue
		}
		for _, e := range adj[u] {
			if dist[e.to] > dist[u]+e.weight {
				return nil, false
			}
		}
	}

	return dist, true
}

func dijkstra(start int, adj [][]Edge) []int {
	n := len(adj)
	dist := make([]int, n)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[start] = 0

	pq := make(PriorityQueue, 0)
	heap.Push(&pq, &Node{id: start, dist: 0})

	for pq.Len() > 0 {
		current := heap.Pop(&pq).(*Node)
		u := current.id
		if current.dist > dist[u] {
			continue
		}
		for _, e := range adj[u] {
			if dist[e.to] > dist[u]+e.weight {
				dist[e.to] = dist[u] + e.weight
				heap.Push(&pq, &Node{id: e.to, dist: dist[e.to]})
			}
		}
	}

	return dist
}

func johnson(n int, edges [][]Edge) ([][]int, bool) {
	adj := make([][]Edge, n+1)
	for u := 0; u < n; u++ {
		adj[u] = append(adj[u], edges[u]...)
	}
	for v := 0; v < n; v++ {
		adj[n] = append(adj[n], Edge{to: v, weight: 0})
	}

	h, ok := bellmanFord(n, adj, n)
	if !ok {
		return nil, false
	}

	for u := 0; u < n; u++ {
		for i := range adj[u] {
			v := adj[u][i].to
			adj[u][i].weight += h[u] - h[v]
		}
	}

	distances := make([][]int, n)
	for u := 0; u < n; u++ {
		dist := dijkstra(u, adj[:n])
		distances[u] = dist
	}

	for u := 0; u < n; u++ {
		for v := 0; v < n; v++ {
			if distances[u][v] != math.MaxInt32 {
				distances[u][v] -= h[u] - h[v]
			}
		}
	}

	return distances, true
}

func main() {
	n := 3
	edges := make([][]Edge, n)
	edges[0] = []Edge{{to: 1, weight: -1}, {to: 2, weight: 4}}
	edges[1] = []Edge{{to: 2, weight: 3}}
	edges[2] = []Edge{{to: 0, weight: 2}, {to: 1, weight: -5}}

	distances, ok := johnson(n, edges)
	if !ok {
		fmt.Println("图中存在负权环")
		return
	}

	for u := 0; u < n; u++ {
		for v := 0; v < n; v++ {
			fmt.Printf("节点 %d 到 %d 的最短距离: %d\n", u, v, distances[u][v])
		}
	}
}

代码说明：

1. 数据结构：使用邻接表存储图，Edge结构体表示边。
2. Bellman-Ford算法：检测负环并计算势能h值。
3. Dijkstra算法：使用优先队列优化，计算调整权重后的最短路径。
4. 权重调整与还原：调整边权确保非负，计算后还原为原始权重。
5. 主函数示例：演示了一个包含负权边的图的处理流程。

该实现能够正确处理负权边，并通过调整权重保证Dijkstra算法的正确性，最终输出所有节点对的最短路径。

通义千问：

Johnson算法是一种用于计算图中所有点对最短路径的算法，特别适用于稀疏图。它的主要思想是通过重新加权（reweighting）来避免使用Floyd-Warshall算法时可能出现的数值溢出问题，同时保持最短路径的相对顺序不变。在Johnson算法中，添加一个新结点s到集合V以形成V’的目的主要有两个：

1. 构造新的权重函数：通过Bellman-Ford算法计算从新增结点s到图中所有其他结点的最短路径值(h(v))，然后用这些值来调整原图中的边权重，使得新图中不存在负权重的边。这样做是为了确保后续可以安全地应用Dijkstra算法（它不支持负权重的边）来寻找最短路径。

2. 解决负权重边的问题：通过上述方法消除负权重边，从而使得可以在新图上对每个源点分别运行Dijkstra算法来找到所有点对的最短路径，这样做的效率通常比直接处理负权重边要高得多。

下面是使用Go语言实现Johnson算法的一个简化示例代码框架。请注意，实际应用时需要根据具体需求进行适当调整和优化。

package main

import (
	"fmt"
	"math"
)

type Edge struct {
	from, to int
	weight   float64
}

func BellmanFord(edges []Edge, V, newSource int) ([]float64, bool) {
	dist := make([]float64, V)
	for i := range dist {
		dist[i] = math.MaxFloat64
	}
	dist[newSource] = 0

	for i := 1; i < V; i++ {
		for _, edge := range edges {
			if dist[edge.from] != math.MaxFloat64 && dist[edge.from]+edge.weight < dist[edge.to] {
				dist[edge.to] = dist[edge.from] + edge.weight
			}
		}
	}

	// Check for negative-weight cycles
	for _, edge := range edges {
		if dist[edge.from] != math.MaxFloat64 && dist[edge.from]+edge.weight < dist[edge.to] {
			return nil, true // Graph contains negative-weight cycle
		}
	}

	return dist, false
}

func Johnson(edges []Edge, V int) ([][]float64, error) {
	newSource := V
	V++ // Add a new vertex

	// Run Bellman-Ford algorithm to find h(v) values and check for negative weight cycles
	h, hasNegativeCycle := BellmanFord(append(edges, Edge{from: newSource, to: 0, weight: 0}), V, newSource)
	if hasNegativeCycle {
		return nil, fmt.Errorf("graph contains negative weight cycle")
	}

	// Reweight the graph
	reweightedEdges := make([]Edge, len(edges))
	for i, edge := range edges {
		reweightedEdges[i] = Edge{
			from:   edge.from,
			to:     edge.to,
			weight: edge.weight + h[edge.from] - h[edge.to],
		}
	}

	// Now run Dijkstra's algorithm from each vertex using reweighted edges
	// This part is omitted for brevity

	return nil, nil // Placeholder return statement
}

func main() {
	// Example usage would go here
	fmt.Println("Johnson Algorithm Example")
}

这段代码展示了如何利用Bellman-Ford算法计算调整权重所需的(h(v))值，并基于此重新加权图中的边。实际应用中，还需要集成Dijkstra算法的部分来完成最终的最短路径计算。

豆包：

Johnson 算法中加入新结点 s 产生 V’ 的目的

Johnson 算法是用于求解有向图中所有节点对之间最短路径的算法，它结合了 Bellman - Ford 算法和 Dijkstra 算法的优点，能够处理带有负权边但无负权环的图。在 Johnson 算法里，在集合 $V$ 中加入新结点 $s$ 产生 $V'$ 主要有以下目的：

1. 创建一个可以到达所有节点的源点：通过引入一个新的节点 $s$，并将其与图中所有节点（集合 $V$ 中的节点）连接起来，且这些边的权重都为 0。这样，节点 $s$ 就可以作为一个超级源点，从它出发能够到达图中的任意节点。

2. 检测负权环：利用 Bellman - Ford 算法以节点 $s$ 为源点对图进行一次最短路径计算。由于 $s$ 可以到达所有节点，如果图中存在负权环，那么在这次计算中就能够检测出来。如果检测到负权环，说明图中不存在有效的最短路径，算法可以提前终止。

3. 重新赋权：计算从 $s$ 到每个节点的最短路径，得到一个势函数 $h$。利用这个势函数对图中的边进行重新赋权，使得所有边的权重变为非负，从而可以使用 Dijkstra 算法来计算最短路径。

Go 语言实现 Johnson 算法

package main

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

// Edge 表示图中的边
type Edge struct {
	to     int
	weight int
}

// Graph 表示图
type Graph struct {
	vertices int
	edges    [][]Edge
}

// newGraph 创建一个新的图
func newGraph(vertices int) *Graph {
	return &Graph{
		vertices: vertices,
		edges:    make([][]Edge, vertices+1), // 额外一个节点 s
	}
}

// addEdge 添加一条边到图中
func (g *Graph) addEdge(from, to, weight int) {
	g.edges[from] = append(g.edges[from], Edge{to, weight})
}

// bellmanFord 实现 Bellman - Ford 算法
func (g *Graph) bellmanFord(source int) ([]int, bool) {
	dist := make([]int, g.vertices+1)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[source] = 0

	for i := 0; i < g.vertices; i++ {
		for u := 0; u <= g.vertices; u++ {
			for _, edge := range g.edges[u] {
				if dist[u] != math.MaxInt32 && dist[u]+edge.weight < dist[edge.to] {
					dist[edge.to] = dist[u] + edge.weight
				}
			}
		}
	}

	// 检测负权环
	for u := 0; u <= g.vertices; u++ {
		for _, edge := range g.edges[u] {
			if dist[u] != math.MaxInt32 && dist[u]+edge.weight < dist[edge.to] {
				return nil, false
			}
		}
	}

	return dist, true
}

// dijkstra 实现 Dijkstra 算法
func (g *Graph) dijkstra(source int, h []int) []int {
	dist := make([]int, g.vertices)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[source] = 0

	pq := make(PriorityQueue, 0)
	heap.Init(&pq)
	heap.Push(&pq, &Item{value: source, priority: 0})

	for pq.Len() > 0 {
		u := heap.Pop(&pq).(*Item).value
		for _, edge := range g.edges[u] {
			newWeight := edge.weight + h[u] - h[edge.to]
			if dist[u] != math.MaxInt32 && dist[u]+newWeight < dist[edge.to] {
				dist[edge.to] = dist[u] + newWeight
				heap.Push(&pq, &Item{value: edge.to, priority: dist[edge.to]})
			}
		}
	}

	// 恢复原始距离
	for i := 0; i < g.vertices; i++ {
		if dist[i] != math.MaxInt32 {
			dist[i] -= h[source] - h[i]
		}
	}

	return dist
}

// johnson 实现 Johnson 算法
func (g *Graph) johnson() ([][]int, bool) {
	// 添加新节点 s
	source := g.vertices
	for i := 0; i < g.vertices; i++ {
		g.addEdge(source, i, 0)
	}

	// 使用 Bellman - Ford 算法计算 h 值
	h, ok := g.bellmanFord(source)
	if!ok {
		return nil, false // 存在负权环
	}

	// 重新赋权
	for u := 0; u < g.vertices; u++ {
		for j, edge := range g.edges[u] {
			g.edges[u][j].weight += h[u] - h[edge.to]
		}
	}

	// 使用 Dijkstra 算法计算所有节点对之间的最短路径
	dist := make([][]int, g.vertices)
	for u := 0; u < g.vertices; u++ {
		dist[u] = g.dijkstra(u, h)
	}

	return dist, true
}

// Item 用于优先队列
type Item struct {
	value    int
	priority int
	index    int
}

// PriorityQueue 实现优先队列
type PriorityQueue []*Item

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

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

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 main() {
	// 创建一个图
	g := newGraph(4)
	g.addEdge(0, 1, -5)
	g.addEdge(0, 2, 2)
	g.addEdge(1, 2, 3)
	g.addEdge(2, 3, 1)

	// 运行 Johnson 算法
	dist, ok := g.johnson()
	if!ok {
		fmt.Println("图中存在负权环")
	} else {
		for i := 0; i < g.vertices; i++ {
			fmt.Printf("从节点 %d 到其他节点的最短路径: %v\n", i, dist[i])
		}
	}
}

代码解释

1. Graph 结构体：表示图，包含顶点数和边的信息。
2. bellmanFord 函数：实现 Bellman - Ford 算法，用于检测负权环并计算势函数 $h$。
3. dijkstra 函数：实现 Dijkstra 算法，用于计算从一个源点到其他所有节点的最短路径。
4. johnson 函数：实现 Johnson 算法，包括添加新节点 $s$、使用 Bellman - Ford 算法计算势函数、重新赋权和使用 Dijkstra 算法计算所有节点对之间的最短路径。
5. PriorityQueue 结构体：实现优先队列，用于 Dijkstra 算法中的节点排序。

通过上述代码，我们可以计算出带有负权边但无负权环的图中所有节点对之间的最短路径。

文心一言：

在 Johnson 算法中，向原始顶点集合 $V$ 中加入一个新结点 $s$ 并产生新的集合 $V'$ 的主要目的是为了能够应用 Bellman-Ford 算法来找到从 $s$ 到所有其他节点的最短路径。由于 Bellman-Ford 算法能够处理带有负权重的边，并且不要求图是连通的，因此通过添加一个虚拟节点 $s$ 并从 $s$ 向所有其他节点添加零权重的边，我们可以确保所有节点都是可达的，从而可以运行 Bellman-Ford 算法。

一旦我们有了从 $s$ 到所有其他节点的最短路径，我们就可以使用这些路径长度来重新加权原始图中的边。重新加权的目的是使得所有边的权重变为非负的，这样我们就可以使用更高效的算法（如 Dijkstra 算法）来计算最短路径。

下面是一个简化的 Go 语言代码示例，它实现了 Johnson 算法的核心部分。请注意，这个示例省略了一些错误处理和优化，并且假设输入的图是有效的（即没有重复的边和自环）。

package main

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

// Edge represents a directed edge with a weight.
type Edge struct {
	to, weight int
}

// Graph represents a directed graph with weighted edges.
type Graph struct {
	vertices int
	edges    [][]Edge
}

// NewGraph creates a new graph with the given number of vertices.
func NewGraph(vertices int) *Graph {
	return &Graph{
		vertices: vertices,
		edges:    make([][]Edge, vertices),
	}
}

// AddEdge adds a directed edge with the given weight to the graph.
func (g *Graph) AddEdge(from, to, weight int) {
	g.edges[from] = append(g.edges[from], Edge{to, weight})
}

// PriorityQueue implements heap.Interface and holds Edges.
type PriorityQueue []*Edge

func (pq PriorityQueue) Len() int           { return len(pq) }
func (pq PriorityQueue) Less(i, j int) bool { return pq[i].weight < pq[j].weight }
func (pq PriorityQueue) Swap(i, j int)      { pq[i], pq[j] = pq[j], pq[i] }

func (pq *PriorityQueue) Push(x interface{}) {
	edge := x.(*Edge)
	*pq = append(*pq, edge)
}

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

// bellmanFord runs the Bellman-Ford algorithm to find the shortest paths from the source node.
func bellmanFord(g *Graph, source int) ([]int, bool) {
	distances := make([]int, g.vertices)
	for i := range distances {
		distances[i] = math.MaxInt32
	}
	distances[source] = 0

	for i := 0; i < g.vertices-1; i++ {
		for u := 0; u < g.vertices; u++ {
			for _, edge := range g.edges[u] {
				v, w := edge.to, edge.weight
				if distances[u]+w < distances[v] {
					distances[v] = distances[u] + w
				}
			}
		}
	}

	// Check for negative-weight cycles
	for u := 0; u < g.vertices; u++ {
		for _, edge := range g.edges[u] {
			v, w := edge.to, edge.weight
			if distances[u]+w < distances[v] {
				return nil, false // Negative-weight cycle detected
			}
		}
	}
	return distances, true
}

// johnson runs the Johnson's algorithm to find all-pairs shortest paths in the graph.
func johnson(g *Graph) ([][]int, error) {
	// Add a new vertex 's' and connect it to all other vertices with zero-weight edges
	s := g.vertices
	g.vertices++
	for i := 0; i < g.vertices-1; i++ {
		g.edges[s] = append(g.edges[s], Edge{i, 0})
	}

	// Run Bellman-Ford from 's'
	distances, ok := bellmanFord(g, s)
	if !ok {
		return nil, fmt.Errorf("graph contains a negative-weight cycle")
	}

	// Reweight the edges
	reweightedEdges := make([][]Edge, g.vertices-1)
	for i := range reweightedEdges {
		reweightedEdges[i] = make([]Edge, len(g.edges[i]))
		copy(reweightedEdges[i], g.edges[i])
	}
	for u := 0; u < g.vertices-1; u++ {
		for i, edge := range g.edges[u] {
			v, w := edge.to, edge.weight
			reweightedEdges[u][i] = Edge{v, w + distances[u] - distances[v]}
		}
	}

	// Run Dijkstra for each vertex to find all-pairs shortest paths
	n := g.vertices - 1
	allPairs := make([][]int, n)
	for i := range allPairs {
		allPairs[i] = make([]int, n)
		for j := range allPairs[i] {
			allPairs[i][j] = math.MaxInt32
		}
		allPairs[i][i] = 0

		pq := &PriorityQueue{}
		heap.Init(pq)
		heap.Push(pq, &Edge{to: i, weight: 0})
		distances := make([]int, n)
		for j := range distances {
			distances[j] = math.MaxInt32
		}
		distances[i] = 0

		for pq.Len() > 0 {
			current := heap.Pop(pq).(*Edge)
			u := current.to
			if distances[u] < current.weight {
				continue
			}
			for _, edge := range reweightedEdges[u] {
				v, w := edge.to, edge.weight
				if distances[u]+w < distances[v] {
					distances[v] = distances[u] + w
					heap.Push(pq, &Edge{to: v, weight: distances[v]})
				}
			}
		}

		for j := range allPairs[i] {
			allPairs[i][j] = distances[j] + distances[j]-distances[i] // Adjust back using h values
			// Note: The above line simplifies to `distances[j] + distances[s] - distances[i] - distances[s]`
			//       which cancels out the `distances[s]` terms, leaving `distances[j] - distances[i] + h[j] - h[i]`
			//       but since h[i] = 0 for the starting node i in Dijkstra, it simplifies further to `distances[j]`.
			//       However, to match the theoretical transformation, we keep the original form using `h` values.
			//       In practice, `distances[j]` is already the correct shortest path length due to reweighting.
			// Here, we directly use `distances[j]` because of the way we reweighted and ran Dijkstra.
		}
	}

	// Remove the added vertex 's'
	g.vertices--

	return allPairs, nil
}

func main() {
	// Create a graph and add edges
	g := NewGraph(4)
	g.AddEdge(0, 1, 3)
	g.AddEdge(0, 2, 8)
	g.AddEdge(1, 2, -4)
	g.AddEdge(1, 3, 2)
	g.AddEdge(2, 1, 7)
	g.AddEdge(2, 3, 4)
	g.AddEdge(3, 0, -2)
	g.AddEdge(3, 2, -5)

	// Find all-pairs shortest paths
	allPairs, err

讯飞星火：

在 Johnson 算法中，集合 V 代表当前已处理的顶点集，而新结点 s 的加入是为了扩展这个集合。这样做的目的是逐步构建最短路径树，并最终找到所有顶点对之间的最短路径。

Johnson 算法分为两个主要部分：

1. 使用 Bellman-Ford 算法计算从单一源点（通常选择图中一个虚拟的源点）到所有其他顶点的最短路径。
2. 重权图，使得所有边的权重非负，然后应用 Dijkstra 算法来找到所有顶点对之间的最短路径。

下面是用 Go 语言实现 Johnson 算法的一个简单示例：

package main

import (
	"fmt"
	"math"
)

const INF = math.MaxFloat64

type Edge struct {
	from, to int
	weight   float64
}

type Graph struct {
	vertices int
	edges    []Edge
}

func NewGraph(vertices int) *Graph {
	return &Graph{
		vertices: vertices,
		edges:    make([]Edge, 0),
	}
}

func (g *Graph) AddEdge(from, to int, weight float64) {
	g.edges = append(g.edges, Edge{from, to, weight})
}

func (g *Graph) BellmanFord(src int) ([]float64, bool) {
	distance := make([]float64, g.vertices)
	for i := range distance {
		distance[i] = INF
	}
	distance[src] = 0

	for i := 0; i < g.vertices-1; i++ {
		for _, edge := range g.edges {
			if distance[edge.from] != INF && distance[edge.from]+edge.weight < distance[edge.to] {
				distance[edge.to] = distance[edge.from] + edge.weight
			}
		}
	}

	for _, edge := range g.edges {
		if distance[edge.from] != INF && distance[edge.from]+edge.weight < distance[edge.to] {
			return nil, false // Negative cycle detected
		}
	}

	return distance, true
}

func (g *Graph) ReweightGraph(h []float64) {
	for i := range g.edges {
		g.edges[i].weight += h[g.edges[i].from] - h[g.edges[i].to]
	}
}

func (g *Graph) Dijkstra(src int) []float64 {
	dist := make([]float64, g.vertices)
	visited := make([]bool, g.vertices)
	for i := range dist {
		dist[i] = INF
	}
	dist[src] = 0

	for {
		u := -1
		for v := 0; v < g.vertices; v++ {
			if !visited[v] && (u == -1 || dist[v] < dist[u]) {
				u = v
			}
		}

		if u == -1 {
			break
		}

		visited[u] = true
		for _, edge := range g.edges {
			if edge.from == u && !visited[edge.to] && dist[u]+edge.weight < dist[edge.to] {
				dist[edge.to] = dist[u] + edge.weight
			}
		}
	}

	return dist
}

func Johnson(g *Graph) [][]float64 {
	// Step 1: Add a new vertex and connect it with zero-weight edges to all other vertices
	newVertex := g.vertices
	g.vertices++
	for i := 0; i < newVertex; i++ {
		g.AddEdge(newVertex, i, 0)
	}

	// Step 2: Run Bellman-Ford from the new vertex to get potential values
	h, ok := g.BellmanFord(newVertex)
	if !ok {
		fmt.Println("Graph contains a negative weight cycle")
		return nil
	}

	// Step 3: Reweight the graph using the potential values
	g.ReweightGraph(h)

	// Step 4: Remove the added vertex and run Dijkstra for each vertex
	result := make([][]float64, newVertex)
	for i := 0; i < newVertex; i++ {
		result[i] = g.Dijkstra(i)
	}

	return result
}

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

	distances := Johnson(g)
	for i, row := range distances {
		fmt.Printf("Distances from vertex %d: %v\n", i, row)
	}
}

在这个代码中，我们首先创建了一个图，并添加了一些边。然后我们实现了 Johnson 算法的各个步骤，包括添加新的顶点、运行 Bellman-Ford 算法以获取势函数、重新加权图以及为每个顶点运行 Dijkstra 算法。最后，我们打印出从每个顶点到其他顶点的最短路径距离。

360智脑：

在 Johnson 算法中，向集合 ( V ) 中加入一个新结点 ( s ) 并生成新的集合 ( V’ ) 的主要目的是为了利用 Bellman-Ford 算法来计算从这个新结点 ( s ) 到所有其他结点的最短路径。这样做有几个好处：

1. 检测负权重环：通过 Bellman-Ford 算法，可以检测图中是否存在负权重环。如果存在负权重环，则 Johnson 算法无法继续进行。
2. 计算重权函数：通过 Bellman-Ford 算法计算从新结点 ( s ) 到所有其他结点的最短路径距离 ( h(v) )，这些距离将用于重新定义边的权重，从而确保所有边的权重都是非负的。

下面是用 Go 语言实现这一部分的代码示例：

package main

import (
	"fmt"
	"math"
)

type Graph struct {
	vertices int
	edges    [][2]int
	weights  map[[2]int]int
}

func NewGraph(vertices int) *Graph {
	return &Graph{
		vertices: vertices,
		edges:    make([][2]int, 0),
		weights:  make(map[[2]int]int),
	}
}

func (g *Graph) AddEdge(u, v, weight int) {
	g.edges = append(g.edges, [2]int{u, v})
	g.weights[[2]int{u, v}] = weight
}

func (g *Graph) BellmanFord(s int) ([]int, bool) {
	dist := make([]int, g.vertices+1)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[s] = 0

	// Relax edges repeatedly
	for i := 0; i < g.vertices; i++ {
		for _, edge := range g.edges {
			u, v := edge[0], edge[1]
			w := g.weights[edge]
			if dist[u] != math.MaxInt32 && dist[u]+w < dist[v] {
				dist[v] = dist[u] + w
			}
		}
	}

	// Check for negative-weight cycles
	for _, edge := range g.edges {
		u, v := edge[0], edge[1]
		w := g.weights[edge]
		if dist[u] != math.MaxInt32 && dist[u]+w < dist[v] {
			return nil, false
		}
	}

	return dist, true
}

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

	// Add a new vertex s and connect it to all other vertices with weight 0
	s := g.vertices
	for i := 0; i < g.vertices; i++ {
		g.AddEdge(s, i, 0)
	}

	dist, hasNegativeCycle := g.BellmanFord(s)
	if !hasNegativeCycle {
		fmt.Println("The graph contains a negative weight cycle.")
		return
	}

	fmt.Println("Distances from the new vertex s:", dist)
}

解释

1. Graph 结构体：表示图，包含顶点数、边和边的权重。
2. NewGraph 函数：创建一个新的图。
3. AddEdge 方法：向图中添加一条边及其权重。
4. BellmanFord 方法：实现 Bellman-Ford 算法，计算从起始结点 ( s ) 到所有其他结点的最短路径，并检测负权重环。
5. main 函数：
   • 创建一个图并添加边。
   • 添加一个新结点 ( s )，并将其连接到所有其他结点，权重为 0。
   • 调用 BellmanFord 方法计算最短路径，并检测负权重环。
   • 输出结果。

通过这种方式，我们可以在图中加入新结点 ( s )，并利用 Bellman-Ford 算法计算从 ( s ) 到所有其他结点的最短路径，从而为后续的 Johnson 算法步骤做好准备。

智谱清言：

在图论中的Johnson算法是用来找到所有顶点对之间的最短路径的算法。在集合V中加入新结点s产生V’的目的是为了将所有边的权重转换成非负权重，这样就可以应用Dijkstra算法来找到最短路径。新结点s与原图中所有的结点都连接，且这些新边的权重都是0。这样做的目的是为了通过s结点重新调整所有结点的权重，使得原图中的所有边权重都变成非负值。
下面是使用Go语言实现Johnson算法的一个基本框架：

package main
import (
	"fmt"
	"math"
)
// 定义图结构
type Graph struct {
	Vertices int
	Edges    [][]int
}
// 添加边
func (g *Graph) AddEdge(u, v, w int) {
	g.Edges[u][v] = w
}
// Bellman-Ford算法实现，用于检测负权重循环并初始化权重调整
func (g *Graph) BellmanFord(s int) ([]int, bool) {
	V := g.Vertices
	dist := make([]int, V)
	for i := 0; i < V; i++ {
		dist[i] = math.MaxInt32
	}
	dist[s] = 0
	for i := 1; i <= V-1; i++ {
		for u := 0; u < V; u++ {
			for v := 0; v < V; v++ {
				weight := g.Edges[u][v]
				if dist[u] != math.MaxInt32 && dist[u]+weight < dist[v] {
					dist[v] = dist[u] + weight
				}
			}
		}
	}
	// 检测负权重循环
	for u := 0; u < V; u++ {
		for v := 0; v < V; v++ {
			weight := g.Edges[u][v]
			if dist[u] != math.MaxInt32 && dist[u]+weight < dist[v] {
				return nil, false // 发现负权重循环
			}
		}
	}
	return dist, true
}
// Dijkstra算法实现
func (g *Graph) Dijkstra(s int, h []int) [][]int {
	V := g.Vertices
	dist := make([][]int, V)
	for i := range dist {
		dist[i] = make([]int, V)
		for j := range dist[i] {
			dist[i][j] = math.MaxInt32
		}
	}
	dist[s][s] = 0
	pq := make(PriorityQueue, 1)
	pq[0] = &Item{vertex: s, priority: 0}
	heap.Init(&pq)
	for pq.Len() > 0 {
		item := heap.Pop(&pq).(*Item)
		u := item.vertex
		for v := 0; v < V; v++ {
			weight := g.Edges[u][v]
			if weight != 0 && dist[s][u]+weight < dist[s][v] {
				dist[s][v] = dist[s][u] + weight
				heap.Push(&pq, &Item{vertex: v, priority: dist[s][v]})
			}
		}
	}
	// 调整权重
	for i := 0; i < V; i++ {
		for j := 0; j < V; j++ {
			if dist[i][j] != math.MaxInt32 {
				dist[i][j] += h[i] - h[j]
			}
		}
	}
	return dist
}
// Johnson算法实现
func (g *Graph) Johnson() ([][]int, bool) {
	V := g.Vertices
	// 添加新结点s并连接所有顶点
	g.AddEdge(V, 0, 0)
	g.AddEdge(V, 1, 0)
	// ... 连接所有顶点到新结点s
	// 使用Bellman-Ford算法计算h值
	h, noNegativeCycle := g.BellmanFord(V)
	if !noNegativeCycle {
		return nil, false // 发现负权重循环
	}
	// 移除新结点s
	g.Edges = g.Edges[:V]
	// 调整图中的权重
	for u := 0; u < V; u++ {
		for v := 0; v < V; v++ {
			if g.Edges[u][v] != 0 {
				g.Edges[u][v] += h[u] - h[v]
			}
		}
	}
	// 对每个顶点运行Dijkstra算法
	allPairsShortestPaths := make([][]int, V)
	for i := 0; i < V; i++ {
		allPairsShortest

天工：

一、Johnson算法中加入新结点s的目的

1. 重新加权
   • 在Johnson算法中，对于包含负权重边的图，直接使用Dijkstra算法是不行的（因为Dijkstra算法要求图中边的权重非负）。加入新结点s的目的之一是通过从s到图中每个顶点添加一条边，构建一个新的图，从而对原有的图进行重新加权，使得新图中的边权重非负。
   • 这种重新加权操作不会改变图中的最短路径结构。具体来说，对于原图中的任意两个顶点u和v，原图中u到v的最短路径权重与重新加权后的图中u到v的最短路径权重加上一个常数（与s相关的常数）相等。
2. 统一计算框架
   • 另一个目的是提供一个统一的计算框架。在重新加权后的图上，可以对每个顶点作为源点运行Dijkstra算法来计算单源最短路径。这样就可以利用Dijkstra算法的高效性（时间复杂度相对较低）来解决包含负权重边的全源最短路径问题。

二、Go语言实现示例（伪代码）

package main

import (
    "fmt"
    "math"
)

// 定义图结构，这里使用邻接矩阵表示
type Graph struct {
    V     int
    edges [][]int
}

// 初始化图
func NewGraph(v int) *Graph {
    g := &Graph{
        V:     v,
        edges: make([][]int, v),
    }
    for i := 0; i < v; i++ {
        g.edges[i] = make([]int, v)
        for j := 0; j < v; j++ {
            g.edges[i][j] = math.MaxInt32
        }
    }
    return g
}

// 添加边
func (g *Graph) AddEdge(u, v, w int) {
    g.edges[u][v] = w
}

// Bellman - Ford算法，用于重新加权
func (g *Graph) BellmanFord(s int) []int {
    dist := make([]int, g.V)
    for i := 0; i < g.V; i++ {
        dist[i] = math.MaxInt32
    }
    dist[s] = 0

    for i := 0; i < g.V - 1; i++ {
        for u := 0; u < g.V; u++ {
            for v := 0; v < g.V; v++ {
                if g.edges[u][v]!= math.MaxInt32 && dist[u]!= math.MaxInt32 && dist[u]+g.edges[u][v] < dist[v] {
                    dist[v] = dist[u] + g.edges[u][v]
                }
            }
        }
    }

    // 检查是否有负权环
    for u := 0; u < g.V; u++ {
        for v := 0; v < g.V; v++ {
            if g.edges[u][v]!= math.MaxInt32 && dist[u]!= math.MaxInt32 && dist[u]+g.edges[u][v] < dist[v] {
                fmt.Println("图中存在负权环")
                return nil
            }
        }
    }

    return dist
}

// Dijkstra算法，用于计算单源最短路径
func (g *Graph) Dijkstra(s int, h []int) []int {
    dist := make([]int, g.V)
    visited := make([]bool, g.V)
    for i := 0; i < g.V; i++ {
        dist[i] = math.MaxInt32
        visited[i] = false
    }
    dist[s] = 0

    for count := 0; count < g.V - 1; count++ {
        u := -1
        min := math.MaxInt32
        for v := 0; v < g.V; v++ {
            if!visited[v] && dist[v] < min {
                min = dist[v]
                u = v
            }
        }

        visited[u] = true

        for v := 0; v < g.V; v++ {
            if!visited[v] && g.edges[u][v]!= math.MaxInt32 && dist[u]!= math.MaxInt32 && dist[u]+g.edges[u][v]-h[u]+h[v] < dist[v] {
                dist[v] = dist[u] + g.edges[u][v] - h[u] + h[v]
            }
        }
    }

    return dist
}

// Johnson算法
func Johnson(g *Graph) [][]int {
    s := g.V
    newG := NewGraph(g.V + 1)
    for u := 0; u < g.V; u++ {
        for v := 0; v < g.V; v++ {
            newG.AddEdge(u, v, g.edges[u][v])
        }
    }
    for v := 0; v < g.V; v++ {
        newG.AddEdge(s, v, 0)
    }

    h := g.BellmanFord(s)
    if h == nil {
        return nil
    }

    allDist := make([][]int, g.V)
    for u := 0; u < g.V; u++ {
        allDist[u] = g.Dijkstra(u, h)
    }

    return allDist
}

你可以使用以下方式调用：

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

    allDist := Johnson(g)
    if allDist!= nil {
        for u := 0; u < len(allDist); u++ {
            for v := 0; v < len(allDist[u]); v++ {
                fmt.Printf("从顶点 %d 到顶点 %d 的最短距离为: %d\n", u, v, allDist[u][v])
            }
        }
    }
}

请注意，这只是一个基本的实现示例，在实际应用中可能需要根据具体情况进行优化，例如使用更高效的数据结构（如优先队列来优化Dijkstra算法部分）。

kimi：

在 Johnson 算法中，加入新节点 s 并将其与集合 V 中的所有节点相连（边的权重为 0），生成新的集合 V′ 的主要目的是为了利用 Bellman-Ford 算法计算从 s 到所有其他节点的最短路径，从而为图中的每条边重新赋予权重，使得所有边的权重变为非负值。这一步骤是 Johnson 算法的核心，因为它允许后续使用 Dijkstra 算法来高效地计算所有节点对之间的最短路径，而 Dijkstra 算法要求图中不能有负权重边。
以下是使用 Go 语言实现 Johnson 算法的代码：

package main

import (
	"fmt"
	"math"
)

type Graph struct {
	vertices int
	edges    map[int]map[int]int
}

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

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

func (g *Graph) BellmanFord(s int) ([]int, bool) {
	dist := make([]int, g.vertices)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[s] = 0

	for i := 0; i < g.vertices-1; i++ {
		for u := range g.edges {
			for v, weight := range g.edges[u] {
				if dist[u] != math.MaxInt32 && dist[u]+weight < dist[v] {
					dist[v] = dist[u] + weight
				}
			}
		}
	}

	for u := range g.edges {
		for v, weight := range g.edges[u] {
			if dist[u] != math.MaxInt32 && dist[u]+weight < dist[v] {
				return nil, false // 图中存在负权重环
			}
		}
	}

	return dist, true
}

func (g *Graph) Dijkstra(s int, h []int) []int {
	dist := make([]int, g.vertices)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[s] = 0

	visited := make([]bool, g.vertices)

	for i := 0; i < g.vertices; i++ {
		u := -1
		for v := 0; v < g.vertices; v++ {
			if !visited[v] && (u == -1 || dist[v] < dist[u]) {
				u = v
			}
		}

		visited[u] = true

		for v, weight := range g.edges[u] {
			newDist := dist[u] + weight + h[u] - h[v]
			if newDist < dist[v] {
				dist[v] = newDist
			}
		}
	}

	return dist
}

func Johnson(g *Graph) ([][]int, bool) {
	// 添加新节点 s 并连接所有其他节点
	s := g.vertices
	g.AddEdge(s, s, 0)
	for i := 0; i < g.vertices; i++ {
		g.AddEdge(s, i, 0)
	}

	// 使用 Bellman-Ford 计算从 s 到所有节点的最短路径
	h, ok := g.BellmanFord(s)
	if !ok {
		return nil, false // 图中存在负权重环
	}

	// 重新计算权重
	for u := range g.edges {
		for v, weight := range g.edges[u] {
			g.edges[u][v] = weight + h[u] - h[v]
		}
	}

	// 使用 Dijkstra 计算所有节点对的最短路径
	dist := make([][]int, g.vertices)
	for i := 0; i < g.vertices; i++ {
		dist[i] = g.Dijkstra(i, h)
	}

	// 恢复原始权重
	for i := 0; i < g.vertices; i++ {
		for j := 0; j < g.vertices; j++ {
			dist[i][j] -= h[i] - h[j]
		}
	}

	return dist, true
}

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

	dist, ok := Johnson(g)
	if !ok {
		fmt.Println("图中存在负权重环")
		return
	}

	for i := 0; i < g.vertices; i++ {
		for j := 0; j < g.vertices; j++ {
			fmt.Printf("从 %d 到 %d 的最短路径长度为: %d\n", i, j, dist[i][j])
		}
	}
}

代码说明：
Bellman-Ford 算法：用于计算从新增节点 s 到所有其他节点的最短路径，并检测负权重环。
边权重重标定：通过 Bellman-Ford 计算的最短路径值 h(v)，重新计算边权重。
Dijkstra 算法：在重标定后的图中，对每个节点运行 Dijkstra 算法。
恢复原始权重：在计算完最短路径后，将边权重恢复为原始值。
输出：
程序会输出图中所有节点对之间的最短路径长度。如果图中存在负权重环，则会提示。

腾讯元宝：

Johnson算法是一种用于求解所有节点对之间最短路径的算法，它结合了Bellman-Ford算法和Dijkstra算法

Johnson算法的主要步骤如下：

1. 在原图G中加入一个新的顶点s，并将其所有边的权重设为0，得到新图G’。
2. 使用Bellman-Ford算法计算从顶点s到其他所有顶点v的最短路径权重h(v)。如果存在负权重环，则算法终止。
3. 对于原图G中的每一条边(u, v)，将其权重修改为w’(u, v) = w(u, v) + h(u) - h(v)。这样处理后，所有边的权重都变为非负值。
4. 对于原图G中的每一个顶点u，使用Dijkstra算法计算从顶点u到其他所有顶点v的最短路径，并将其与h(u)和h(v)相加，得到原始图G中u到v的最短路径。
5. 恢复原始图G的边权重。

以下是使用Go语言实现的Johnson算法：

package main

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

type Edge struct {
	from, to, weight int
}

type Graph struct {
	vertices int
	edges    []Edge
}

func NewGraph(vertices int) *Graph {
	return &Graph{
		vertices: vertices,
		edges:    make([]Edge, 0),
	}
}

func (g *Graph) AddEdge(from, to, weight int) {
	g.edges = append(g.edges, Edge{from, to, weight})
}

func bellmanFord(g *Graph, s int) ([]int, bool) {
	dist := make([]int, g.vertices)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[s] = 0

	for i := 1; i < g.vertices; i++ {
		for _, e := range g.edges {
			if dist[e.from]+e.weight < dist[e.to] {
				dist[e.to] = dist[e.from] + e.weight
			}
		}
	}

	for _, e := range g.edges {
		if dist[e.from]+e.weight < dist[e.to] {
			return nil, true // 存在负权重环
		}
	}

	return dist, false
}

func dijkstra(g *Graph, s int, h []int) []int {
	dist := make([]int, g.vertices)
	for i := range dist {
		dist[i] = math.MaxInt32
	}
	dist[s] = 0

	pq := &PriorityQueue{}
	heap.Init(pq)
	heap.Push(pq, &Item{vertex: s, priority: 0})

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

		for _, e := range g.edges {
			if e.from == u {
				v := e.to
				w := e.weight + h[u] - h[v]
				if dist[u]+w < dist[v] {
					dist[v] = dist[u] + w
					heap.Push(pq, &Item{vertex: v, priority: dist[v]})
				}
			}
		}
	}

	for i := range dist {
		if dist[i] != math.MaxInt32 {
			dist[i] += h[i] - h[s]
		}
	}

	return dist
}

func johnson(g *Graph) ([][]int, bool) {
	// 添加新顶点s
	s := g.vertices
	g.vertices++
	g.edges = append(g.edges, make([]Edge, 0, len(g.edges)))

	// 使用Bellman-Ford算法计算h(v)
	h, hasNegativeCycle := bellmanFord(g, s)
	if hasNegativeCycle {
		return nil, true // 存在负权重环
	}

	// 使用Dijkstra算法计算所有节点对之间的最短路径
	allPairsShortestPaths := make([][]int, g.vertices-1)
	for i := range allPairsShortestPaths {
		allPairsShortestPaths[i] = dijkstra(g, i, h)
	}

	return allPairsShortestPaths, false
}

// 优先队列实现
type Item struct {
	vertex   int
	priority 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].priority < pq[j].priority
}

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 main() {
	g := NewGraph(3)
	g.AddEdge(0, 1, -5)
	g.AddEdge(1, 2, 2)
	g.AddEdge(2, 0, 3)

	allPairsShortestPaths, hasNegativeCycle := johnson(g)
	if hasNegativeCycle {
		fmt.Println("图中存在负权重环")
	} else {
		fmt.Println("所有节点对之间的最短路径：")
		for _, row := range allPairsShortestPaths {
			fmt.Println(row)
		}
	}
}

这段代码首先定义了一个图的结构体，包含顶点数和边的列表。然后实现了Johnson算法的主要步骤，包括Bellman-Ford算法、Dijkstra算法和优先队列的实现。最后，在main函数中创建了一个图并运行Johnson算法，输出所有节点对之间的最短路径。