### 1. Introducing the Bellman-Ford Algorithm

Named after its developers Richard Bellman and Lester Ford, the Bellman-Ford algorithm solves the single-source problem in the general case where edges of the graph can have negative weight. However, the graph must not contain negative cycles, as they result in undefined shortest paths.

While Dijkstra's algorithm provides a fast and efficient solution for graphs with non-negative weights, the Bellman-Ford algorithm handles negative weights, making it versatile for a wider variety of scenarios.

#### 1.1 Theoretical Framework of Bellman-Ford

Like Dijkstra's algorithm, the Bellman-Ford algorithm operates in a step-by-step fashion, with each iteration improving upon the estimation of the shortest paths. The fundamental difference, however, lies in the way they handle edges and update distances.

The central idea behind the Bellman-Ford algorithm is to relax each edge of the graph $|V|-1$ times, where $|V|$ is the number of vertices. The algorithm assumes the shortest path to any vertex can have at most $|V|-1$ edges. Hence, the number of times we relax each edge.

Let's represent our graph as $G = (V, E)$ where $V$ is the set of vertices and $E$ is the set of edges. Bellman-Ford uses the following formula to update the distances:

$D_t = min(D_t, D_s + w(s,t))$

Where, $D_t$ is the shortest path from $s$ to $t$, and $w(s,t)$ is the weight of edge from $s$ to $t$.

##### 1.1.1 Understanding the Algorithm

The algorithm initializes the distance to the source vertex as 0 and to all other vertices as infinity. It then relaxes all the edges $|V|-1$ times. Relaxing an edge means minimizing the distance to the vertices it's connected to.

Finally, the algorithm performs a last iteration over all edges to detect any negative cycles. If it's able to further minimize any distance, it means there's a negative cycle, and the algorithm returns false, indicating that no solution exists.

### 2. Implementing Bellman-Ford Algorithm in C++

Let's see how we can translate the theory into practice with a C++ implementation of the Bellman-Ford algorithm. We'll create a function named `BellmanFord` that calculates the shortest distances to all vertices from a given source.

#### 2.1 Detailed Code

Below is the C++ code for Bellman-Ford algorithm:

```
#include <bits/stdc++.h>
using namespace std;
#define INF 1000000000
struct Edge {
int a, b, cost;
};
vector<int> BellmanFord(int n, int s, vector<Edge> &edges) {
vector<int> d(n, INF);
d[s] = 0;
for (int i = 0; i < n-1; ++i) {
for (Edge e : edges) {
if (d[e.a] < INF)
if (d[e.a] + e.cost < d[e.b])
d[e.b] = d[e.a] + e.cost;
}
}
return d;
}
```

##### 2.1.1 Code Explanation

The function `BellmanFord` takes as input the number of vertices `n`, the source vertex `s`, and a list of `edges`. Each edge is a struct containing two vertices `a` and `b`, and the cost of the edge `cost`.

The distance from the source vertex to itself is set to 0, while the distance to all other vertices is set to infinity (`INF`). The algorithm then performs $n-1$ iterations. In each iteration, it goes through all the edges and tries to relax them.

Relaxing an edge means checking if we can improve the shortest distance to a vertex by taking that edge. If so, we update the distance. After $n-1$ iterations, we have the shortest distances to all vertices from the source `s`.

### 3. Complexity Analysis of Bellman-Ford

The Bellman-Ford algorithm has a time complexity of $O(|V| \cdot |E|)$ due to the fact that it needs to relax all edges $|V|-1$ times. This makes it slower than Dijkstra's algorithm for sparse graphs. However, it is more versatile as it can handle graphs with negative weights.

In space complexity, it uses $O(|V|)$ space for maintaining the distance array, thus, the space complexity is linear.

### 4. Conclusion

The Bellman-Ford algorithm, despite being slower than Dijkstra's algorithm, has its unique use-cases. By allowing negative weights, it is applicable to a variety of real-world problems that involve loss or reduction. Furthermore, it can detect negative cycles, adding another layer of utility.

### 5. In the Next Unfolding...

As we continue our journey through the landscape of graph algorithms, we'll step into the fascinating world of "Floyd-Warshall Algorithm: Finding All Pairs of Shortest Paths".

Ready to discover how to calculate the shortest path between every pair of vertices in a graph? Then prepare yourself for the next exploration as we demystify the dynamic programming approach used by the Floyd-Warshall algorithm. Stay tuned!