0% found this document useful (0 votes)
65 views

Bellman Ford Algorithm: Title

This document describes the Bellman-Ford and Dijkstra's algorithms for finding the shortest path in a graph. It provides pseudocode and C code implementations of both algorithms. The Bellman-Ford algorithm finds the shortest paths from a single source vertex to all other vertices in a weighted graph, even if negative edge weights are present. Dijkstra's algorithm also finds shortest paths but does not work for graphs with negative edge weights. Test cases and sample outputs are provided for the Bellman-Ford C code.

Uploaded by

Anjana Maganti
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
65 views

Bellman Ford Algorithm: Title

This document describes the Bellman-Ford and Dijkstra's algorithms for finding the shortest path in a graph. It provides pseudocode and C code implementations of both algorithms. The Bellman-Ford algorithm finds the shortest paths from a single source vertex to all other vertices in a weighted graph, even if negative edge weights are present. Dijkstra's algorithm also finds shortest paths but does not work for graphs with negative edge weights. Test cases and sample outputs are provided for the Bellman-Ford C code.

Uploaded by

Anjana Maganti
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 10

BELLMAN FORD ALGORITHM

Title:

C program to find the shortest path across vertices of a given graph using Bellman-Ford
Algorithm.

Objectives:

At the end of this activity we will be able to

 Find the shortest path between any two pair of vertices along with intermediate
vertices using Bellman-Ford algorithm.
 Know the time complexity of the program.

Problem Statement:

The program is to find the shortest path. We are given a weighted, directed graph G = (V, E)
with source and weight function W: E-> R, with possibly negative weight edges. We have to
find the shortest path from given source vertex and destination vertex.

Algorithm:

1. Start
2. A graph with source vertex is taken as input.
3. The cost (distance[20]) of each vertex is initialised to 1000 and the
predecessor(parent[20]) to -1.
4. The cost of source is initialised to 0.
5. Here, comes the iteration of created matrix of distances that is V-1 times where V is
no. of vertices.
(a) If distance[v] > distance[u] + weight of edge uv
Then distance[v] = weight of edge uv + distance[u]
(b) Else distance[v] = distance[v]
6. After this iteration again the same process is tested and if the iteration is done more
than V-1 times implies there is a negative cycle and is impossible to print the shortest
path as output.

Program(code) in C:
#include <stdio.h>
#include <stdlib.h>
int bellman_ford(int g[20][20],int V,int e,int edge[20][2])
{
int i,u,v,k,distance[20],parent[20],s,flag=1;
for(i=0;i<V;i++)
distance[i]=1000,parent[i]=-1;
printf("enter source: ");
scanf("%d",&s);
distance[s-1]=0;
for(i=0;i<V-1;i++)
{
for(k=0;k<e;k++)
{
u=edge[k][0],v=edge[k][1];
if(distance[u]+g[u][v]<distance[v])
{
distance[v]=distance[u]+g[u][v];
parent[v]=u;
}
}
}
for(k=0;k<e;k++)
{
u=edge[k][0],v=edge[k][1];
if(distance[u]+g[u][v]<distance[v])
flag=0;
}
if(flag)
for(i=0;i<V;i++)
printf("vertex %d-> cost=%d parent =%d\n",i+1,distance[i],parent[i]+1);
return flag;

}
int main()
{
int v,edge[20][2],g[20][20],i,j,k=0;
printf("bellman ford\n");
printf("enter no. of vertices:");
scanf("%d",&v);
printf("enter graph in matrix form:\n");
for(i=0;i<v;i++)
for(j=0;j<v;j++)
{
scanf("%d",&g[i][j]);
if(g[i][j]!=0)
edge[k][0]=i,edge[k++][1]=j;

}
if(bellman_ford(g,v,k,edge))
printf("\n no negative weight cycle\n");
else printf("\n negative weight cycle exists\n");
return 0;
}

Test case - 1:
bellman ford
enter no. of vertices:5
enter graph in matrix form:
0 2 1000 1 1000
1000 0 3 1000 1000
1000 1000 0 1000 1
1000 -2 1000 0 1000
1000 1000 1000 1 0
enter source: 1
vertex 1-> cost=0 parent =0
vertex 2-> cost=-1 parent =4
vertex 3-> cost=2 parent =2
vertex 4-> cost=1 parent =1
vertex 5-> cost=3 parent =3

no negative weight cycle


----------------------------------
bellman ford
enter no. of vertices:5
enter graph in matrix form:
0 2 1000 1 1000
1000 0 3 1000 1000
1000 1000 0 1000 1
1000 -2 1000 0 1000
1000 1000 1000 1 0
enter source: 2
vertex 1-> cost=1000 parent =0
vertex 2-> cost=0 parent =0
vertex 3-> cost=3 parent =2
vertex 4-> cost=5 parent =5
vertex 5-> cost=4 parent =3

no negative weight cycle


-------------------------------------

bellman ford
Enter no. of vertices: 5
Enter graph in matrix form:
0 2 1000 1 1000
1000 0 3 1000 1000
1000 1000 0 1000 1
1000 -2 1000 0 1000
1000 1000 1000 1 0
Enter source: 3
Vertex 1 -> cost = 1000 parent = 0
Vertex 2 -> cost = 0 parent = 4
Vertex 3 -> cost = 0 parent = 0
Vertex 4 -> cost = 2 parent = 5
Vertex 5 -> cost = 1 parent = 3

No negative weight cycle


------------------------------------------

bellman ford
enter no. of vertices:5
enter graph in matrix form:
0 2 1000 1 1000
1000 0 3 1000 1000
1000 1000 0 1000 1
1000 -2 1000 0 1000
1000 1000 1000 1 0
enter source: 4
vertex 1-> cost=998 parent =2
vertex 2-> cost=-2 parent =4
vertex 3-> cost=1 parent =2
vertex 4-> cost=0 parent =0
vertex 5-> cost=2 parent =3

no negative weight cycle


-----------------------------------------

bellman ford
enter no. of vertices:5
enter graph in matrix form:
0 2 1000 1 1000
1000 0 3 1000 1000
1000 1000 0 1000 1
1000 -2 1000 0 1000
1000 1000 1000 1 0
enter source: 5
vertex 1-> cost=999 parent =2
vertex 2-> cost=-1 parent =4
vertex 3-> cost=2 parent =2
vertex 4-> cost=1 parent =5
vertex 5-> cost=0 parent =0

no negative weight cycle


-------------------------------------

Test case -2 :
bellman ford

Enter no. of vertices: 8

Enter graph in matrix form:

0 3 1000 5 1000 2 1000 1000


1000 0 -4 1000 1000 1000 1000 1000

1000 1000 0 1000 1000 1000 1000 4

1000 1000 1000 0 6 1000 1000 1000

1000 1000 1000 -3 0 1000 1000 8

1000 1000 1000 1000 1000 0 3 1000

1000 1000 1000 1000 1000 -6 0 7

1000 1000 1000 1000 1000 1000 1000 0

Enter source: 1

Negative weight cycle exists

----------------------------------------------

Conclusion: Simulating the above C program helped me understand the bellman ford
algorithm and its complexity.

DIJKSTRA’S ALGORITHM

Algorithm:

1. Dijkstra functions is defined with parameters graph, no. of edges and source.

2. The cost of source is set to zero.

3. While(Q!= empty)

a. U = minimun weight of two vertices.

b. If(distance[u] + g[u][i] < distance[i])


Distance[i] = distance[u] + g[u][i]

Parent[i] = u + 1

Program in C:

#include <stdio.h>
#include <stdlib.h>
int G[20][20] , distance[20] , inSet[20] , q[20] , parent[20] ;
void print( int V )
{
int i ;
for ( i = 0 ; i < V ; i++ )
printf("i = %d parent = %d distance from source = %d \n", i + 1 , parent[i] ,
distance[i] ) ;
}
int Q( int V )
{
int sum = 0 , i ;
for( i = 0 ; i < V ; i++ )
sum += q[i] ;
return sum ;
}
int extractMin( int V )
{
int i , idx , min = 1000 ;
for ( i = 0 ; i < V ; i++ )
{
if ( distance[i] <= min && inSet[i] == 0 )
min = distance[i] , idx = i ;
}
q[idx] = 0 ;
return idx ;
}
void dijkstra ( int S , int V )
{
int u , i , check_empty = Q(V);

while( check_empty >0 )


{
u = extractMin(V) ;

inSet[u] = 1 ;
q[u] = 0 ;
for( i = 0 ; i < V ; i++ )
{
if( G[u][i] > 0 )
{
if( distance[u] + G[u][i] < distance[i] )
distance[i] = distance[u] + G[u][i] , parent[i] = u + 1 ;
}
}
check_empty = Q(V);
}

print(V);
}
int main()
{
int V , i , j , S;
printf ( "Enter no. of vertices: " ) ;
scanf ( "%d" , &V ) ;

printf ( "Enter graph in matrix form:\n" ) ;


for ( i = 0 ; i < V ; i++ )
{
for( j = 0 ; j < V ; j++ )
scanf( "%d" , &G[i][j] );
}
for ( i = 0 ; i < V ; i++ )
distance[i] = 1000 , inSet[i] = 0 , q[i] = 1 , parent[i] = -1 ;

printf ( "Enter the source vertex: " ) ;


scanf ( "%d" , &S ) ;
distance[ S - 1 ] = 0 ;
dijkstra ( S , V ) ;
return 0;
}

You might also like