Implemented a Bellman Ford Algorithm

#include <iostream>
#include <vector>
#include <climits>

using namespace std;

// Structure to represent an edge in the graph
struct Edge {
    int source, destination, weight;
};

// Class to represent a directed, weighted graph
class Graph {
public:
    int vertices, edges;
    vector<Edge> edgeList;

    Graph(int v, int e) {
        vertices = v;
        edges = e;
        edgeList.resize(e);
    }

    void addEdge(int source, int destination, int weight) {
        edgeList.push_back({source, destination, weight});
    }

    void bellmanFord(int source) {
        vector<int> distance(vertices, INT_MAX);
        distance[source] = 0;

        for (int i = 0; i < vertices - 1; ++i) {
            for (const Edge& edge : edgeList) {
                int u = edge.source;
                int v = edge.destination;
                int w = edge.weight;

                if (distance[u] != INT_MAX && distance[u] + w < distance[v]) {
                    distance[v] = distance[u] + w;
                }
            }
        }

        // Check for negative-weight cycles
        for (const Edge& edge : edgeList) {
            int u = edge.source;
            int v = edge.destination;
            int w = edge.weight;

            if (distance[u] != INT_MAX && distance[u] + w < distance[v]) {
                cout << "Graph contains a negative-weight cycle!" << endl;
                return;
            }
        }

        // Print the shortest distances from the source vertex
        cout << "Shortest distances from vertex " << source << ":" << endl;
        for (int i = 0; i < vertices; ++i) {
            cout << "Vertex " << i << ": Distance = " << distance[i] << endl;
        }
    }
};

int main() {
    int v, e, source;
    cout << "Enter the number of vertices and edges: ";
    cin >> v >> e;

    Graph graph(v, e);

    cout << "Enter the edges (source, destination, weight):" << endl;
    for (int i = 0; i < e; ++i) {
        int source, destination, weight;
        cin >> source >> destination >> weight;
        graph.addEdge(source, destination, weight);
    }

    cout << "Enter the source vertex: ";
    cin >> source;

    graph.bellmanFord(source);

    return 0;
}