Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Golang program to implement Bellman ford algorithm
The bellman ford algorithm is a graph traversal method that is used to find the shortest distance in a weighted network from a particular vertex to all the vertices. In this article, we will write a Go language program to implement Bellman ford algorithm. This algorithm is used to handle the situations where you need to find the shortest path from the source vertex to other vertices in a weighted directed graph. It works by updating the distance value of the vertices if the shortest path is found.
Syntax
func make ([] type, size, capacity)
The make function in go language is used to create an array/map it accepts the type of variable to be created, its size and capacity as arguments
func append(slice, element_1, element_2…, element_N) []T
The append function is used to add values to an array slice. It takes number of arguments. The first argument is the array to which we wish to add the values followed by the values to add. The function then returns the final slice of array containing all the values.
func len(v Type) int
The len() function is used to get the length of a any parameter. It takes one parameter as the data type variable whose length we wish to find and returns the integer value which is the length of the variable.
Algorithm
Step 1 − Create an Edge struct to represent an edge in the graph, with three fields source of type int, destination of type int and weight of type float.
Step 2 − Then, create a Graph struct to represent a weighted directed graph, with two fields - number of vertices of type int and a slice of edges.
Step 3 − Create a BellmanFord() function that takes a graph and source vertex as input and returns the arrays of distances and previous vertices
Step 4 − Then, initialize the distance array (dist[]) and previous vertex array (prev[]) for all vertices. Check whether a negative weight cycle exists with dist[u] + w is smaller than dist[v].
Step 5 − Create a PrintShortestPaths() function that prints the shortest paths from the source vertex to all other vertices
Step 6 − Then, construct the shortest path by traversing the previous vertices array starting and print distance and path. Create a main function and Initialize the source vertex with 0
Step 7 − Finally, execute the Bellman-Ford algorithm and obtain the distances and previous vertex arrays, if the arrays are not nil, print the shortest paths from the source vertex.
Example
In this article, we will write a Go language program to implement Bellman ford algorithm to find shortest path in a weighted directed graph.
package main
import (
"fmt"
"math"
)
type Edge struct {
src int
dest int
weight float64
}
type Graph struct {
vertices int
edges []Edge
}
func InitGraph(vertices int) *Graph {
return &Graph{
vertices: vertices,
edges: make([]Edge, 0),
}
}
func (g *Graph) AddEdge(src, dest int, weight float64) {
g.edges = append(g.edges, Edge{src, dest, weight})
}
func BellmanFord(g *Graph, source int) ([]float64, []int) {
dist := make([]float64, g.vertices)
prev := make([]int, g.vertices)
for i := 0; i < g.vertices; i++ {
dist[i] = math.Inf(1)
prev[i] = -1
}
dist[source] = 0
for i := 1; i < g.vertices; i++ {
for _, edge := range g.edges {
u := edge.src
v := edge.dest
w := edge.weight
if dist[u]+w < dist[v] {
dist[v] = dist[u] + w
prev[v] = u
}
}
}
for _, edge := range g.edges {
u := edge.src
v := edge.dest
w := edge.weight
if dist[u]+w < dist[v] {
fmt.Println("Graph contains a negative weight cycle")
return nil, nil
}
}
return dist, prev
}
func PrintShortestPaths(dist []float64, prev []int, source int) {
fmt.Println("Shortest Paths from vertex", source)
for i := 0; i < len(dist); i++ {
if dist[i] == math.Inf(1) {
fmt.Printf("Vertex %d is not reachable\n", i)
} else {
path := []int{}
j := i
for j != -1 {
path = append([]int{j}, path...)
j = prev[j]
}
fmt.Printf("Vertex %d: Distance=%f, Path=%v\n", i, dist[i], path)
}
}
}
func main() {
g := InitGraph(5)
g.AddEdge(0, 1, 6)
g.AddEdge(0, 2, 7)
g.AddEdge(1, 2, 8)
g.AddEdge(1, 3, -4)
g.AddEdge(1, 4, 5)
g.AddEdge(2, 3, 9)
g.AddEdge(2, 4, -3)
g.AddEdge(3, 1, 7)
g.AddEdge(4, 0, 2)
g.AddEdge(4, 3, 7)
source := 0
dist, prev := BellmanFord(g, source)
if dist != nil && prev != nil {
PrintShortestPaths(dist, prev, source)
}
}
Output
Shortest Paths from vertex 0 Vertex 0: Distance=0.000000, Path=[0] Vertex 1: Distance=6.000000, Path=[0 1] Vertex 2: Distance=7.000000, Path=[0 2] Vertex 3: Distance=2.000000, Path=[0 1 3] Vertex 4: Distance=4.000000, Path=[0 2 4]
Conclusion
In this article, we have executed the program for implementing Bellman-ford algorithm using structs. We explored the working of this algorithm and also saw how to represent a graph using an adjacency list.
157 Views
