Scribd
Upload
9 views3 pages

Experiment 5

The document describes using the Bellman-Ford algorithm to find the shortest path between vertices in a graph. It defines a BellmanFord class that takes a source vertex and adjacency matrix as input. The BellmanFordEvaluation method performs the Bellman-Ford algorithm by initializing all distances as infinity, setting the source distance to 0, and iterating through the vertices to relax edges and update distances until it has iterated numberofvertices - 1 times. It then prints the calculated distances from the source to each vertex.

Uploaded by

Jaikishore M
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
9 views3 pages

Experiment 5

The document describes using the Bellman-Ford algorithm to find the shortest path between vertices in a graph. It defines a BellmanFord class that takes a source vertex and adjacency matrix as input. The BellmanFordEvaluation method performs the Bellman-Ford algorithm by initializing all distances as infinity, setting the source distance to 0, and iterating through the vertices to relax edges and update distances until it has iterated numberofvertices - 1 times. It then prints the calculated distances from the source to each vertex.

Uploaded by

Jaikishore M
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

Shortest path between vertices using bellman-ford algorithm

import java.util.Scanner;

public class BellmanFord

private int distances[ ];

private int numberofvertices;

public static final int MAX_VALUE = 999;

public BellmanFord(int numberofvertices)

this.numberofvertices = numberofvertices;

distances = new int[numberofvertices + 1];

public void BellmanFordEvaluation(int source, int adjacencymatrix[ ][ ])

for (int node = 1; node <= numberofvertices; node++)

distances[node] = MAX_VALUE;

distances[source] = 0;

for (int node = 1; node <= numberofvertices - 1; node++)

for (int sourcenode = 1; sourcenode <= numberofvertices; sourcenode++)

for (int destinationnode = 1; destinationnode <= numberofvertices; destinationnode++)

if (adjacencymatrix[sourcenode][destinationnode] != MAX_VALUE)

if (distances[destinationnode] > distances[sourcenode] + distances[destinationnode] =

distances[sourcenode]+adjacencymatrix[sourcenode][destinationnode];

}
Shortest path between vertices using bellman-ford algorithm

for (int vertex = 1; vertex <= numberofvertices; vertex++)

System.out.println("distance of source " + source + " to "+ vertex + " is " + distances[vertex]);

public static void main(String[ ] args)

int numberofvertices = 0;

int source, destination;

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the number of vertices");

numberofvertices = scanner.nextInt();

int adjacencymatrix[ ][ ] = new int[numberofvertices + 1][numberofvertices + 1];

System.out.println("Enter the adjacency matrix");

for (int sourcenode = 1; sourcenode <= numberofvertices; sourcenode++)

for (int destinationnode = 1; destinationnode <= numberofvertices; destinationnode++)

adjacencymatrix[sourcenode][destinationnode] = scanner.nextInt();

if (sourcenode == destinationnode)

adjacencymatrix[sourcenode][destinationnode] = 0;

continue;

if (adjacencymatrix[sourcenode][destinationnode] == 0)
Shortest path between vertices using bellman-ford algorithm

adjacencymatrix[sourcenode][destinationnode] = MAX_VALUE;

System.out.println("Enter the source vertex");

source = scanner.nextInt();

BellmanFord bellmanford = new BellmanFord(numberofvertices);

bellmanford.BellmanFordEvaluation(source,adjacencymatrix);

scanner.close();

You might also like