What is the Bellman-Ford algorithm in C++?

Can you explain the Bellman-Ford algorithm in C++?

Sure! The Bellman-Ford algorithm is used to find the shortest path from a single source vertex to all other vertices in a weighted graph, even if the graph contains negative weight edges.

How does it handle negative weight cycles?

The Bellman-Ford algorithm can detect negative weight cycles. If it finds a shorter path after V-1 iterations (where V is the number of vertices), it indicates a negative cycle.

Can you show me a simple implementation in C++?

Absolutely! Here's a basic implementation:

#include <iostream>
#include <vector>
#include <climits>
using namespace std;

void bellmanFord(vector<vector<int>>& edges, int V, int E, int src) {
    vector<int> dist(V, INT_MAX);
    dist[src] = 0;

    for (int i = 1; i <= V - 1; i++) {
        for (int j = 0; j < E; j++) {
            int u = edges[j][0];
            int v = edges[j][1];
            int weight = edges[j][2];
            if (dist[u] != INT_MAX && dist[u] + weight < dist[v]) {
                dist[v] = dist[u] + weight;
            }
        }
    }

    // Check for negative-weight cycles
    for (int j = 0; j < E; j++) {
        int u = edges[j][0];
        int v = edges[j][1];
        int weight = edges[j][2];
        if (dist[u] != INT_MAX && dist[u] + weight < dist[v]) {
            cout << "Graph contains negative weight cycle";
            return;
        }
    }

    // Print the distance array
    for (int i = 0; i < V; i++) {
        cout << "Distance from source to vertex " << i << " is " << dist[i] << endl;
    }
}

What are the time and space complexities of this algorithm?

The time complexity of the Bellman-Ford algorithm is O(V * E), where V is the number of vertices and E is the number of edges. The space complexity is O(V) for storing the distance values.