The Bellman-Ford Algorithm is a popular algorithm for computing the shortest paths from a single source vertex to all the other vertices in a weighted digraph. It is widely used in network routing protocols and is also useful in other applications such as detecting negative cycles in a graph.

Here are the steps involved in the Bellman-Ford Algorithm:

Initialize the distance to the source vertex as 0 and the distance to all other vertices as infinity.
Repeat the following step V – 1 times, where V is the total number of vertices in the graph:
a. For each edge (u, v) in the graph, calculate the distance to vertex v as the minimum of its current distance and the distance to vertex u plus the weight of the edge (u, v).
Check for the presence of negative cycles in the graph by repeating step 2 and checking if any distance is updated. If a distance is updated, then there is a negative cycle in the graph.
Return the distances to all the vertices as the output of the algorithm.

Example of finding the shortest paths from vertex A to all the other vertices in the following weighted digraph using the Bellman-Ford Algorithm:

    -1      4
A --------> B
|           | \
|      2    |  3
v           v  v
C --------> D ---> E
      2        -3

Initialize the distance to vertex A as 0 and the distance to all other vertices as infinity: dist[A] = 0, dist[B] = dist[C] = dist[D] = dist[E] = infinity.
Repeat the following step 4 times: a. For each edge (u, v) in the graph, calculate the distance to vertex v as the minimum of its current distance and the distance to vertex u plus the weight of the edge (u, v).
- For edge (A, B): dist[B] = min(dist[B], dist[A] + weight(A, B)) = min(infinity, 0 + 4) = 4.
- For edge (A, C): dist[C] = min(dist[C], dist[A] + weight(A, C)) = min(infinity, 0 + 2) = 2.
- For edge (B, D): dist[D] = min(dist[D], dist[B] + weight(B, D)) = min(infinity, 4 + 3) = 7.
- For edge (B, E): dist[E] = min(dist[E], dist[B] + weight(B, E)) = min(infinity, 4 + -3) = 1.
- For edge (C, D): dist[D] = min(dist[D], dist[C] + weight(C, D)) = min(7, 2 + 2) = 4.
- For edge (D, E): dist[E] = min(dist[E], dist[D] + weight(D, E)) = min(1, 7 + -3) = 1.
  b. The distances after each iteration are:
- dist[A] = 0, dist[B] = 4, dist[C] = 2, dist[D] = 4, dist[E] = 1.
Check for the presence of negative cycles by repeating step 2 and checking if any distance is updated. Since no distance is updated in this step, there is no negative cycle in the graph.
Return the distances to all the vertices as the output of the algorithm: dist[A] = 0, dist[B] = 4, dist[C] =