🕷️ Crawler Inspector

[](https://www.algorithmexamples.com/) [](https://www.algorithmexamples.com/) # Bellman- Ford Algorithm The Bellman-Ford algorithm is a graph search algorithm that finds the shortest path from a single source node to all other nodes in a weighted graph, even when the graph contains negative weight edges. Conceived by Richard Bellman and Lester Ford in the late 1950s, it is a popular choice for solving the single-source shortest path problem due to its simplicity and ability to handle negative weight cycles. The algorithm essentially iterates through the graph's edges and updates the shortest path estimates iteratively until a fixed point is reached or a negative-weight cycle is detected. In the Bellman-Ford algorithm, the process of edge relaxation is performed, which involves updating the shortest path estimates by iterating through all the edges in the graph. The algorithm runs for (V-1) iterations, where V is the number of vertices in the graph, and in each iteration, it attempts to improve the current shortest path estimates. If a negative-weight cycle is present in the graph, the algorithm will detect it by running an extra iteration and checking if any shortest path estimates continue to be updated. This allows the Bellman-Ford algorithm to report the presence of negative-weight cycles and warn that no solution exists in such cases. Despite being slower than other shortest path algorithms like Dijkstra's algorithm, the Bellman-Ford algorithm remains a popular choice for its versatility in handling graphs with negative weights and its ease of implementation. ``` #include<stdio.h> #include<stdlib.h> #include<limits.h> #include<string.h> //Structure for storing edge struct Edge{ int src,dst,weight; }; //Structure for storing a graph struct Graph{ int vertexNum; int edgeNum; struct Edge* edges; }; //Constructs a graph with V vertices and E edges void createGraph(struct Graph* G,int V,int E){ G->vertexNum = V; G->edgeNum = E; G->edges = (struct Edge*) malloc(E * sizeof(struct Edge)); } //Adds the given edge to the graph void addEdge(struct Graph* G, int src, int dst, int weight){ static int ind; struct Edge newEdge; newEdge.src = src; newEdge.dst = dst; newEdge.weight = weight; G->edges[ind++]= newEdge; } //Utility function to find minimum distance vertex in mdist int minDistance(int mdist[], int vset[], int V){ int minVal = INT_MAX, minInd ; for(int i=0; i<V;i++) if(vset[i] == 0 && mdist[i] < minVal){ minVal = mdist[i]; minInd = i; } return minInd; } //Utility function to print distances void print(int dist[], int V){ printf("\nVertex Distance\n"); for(int i = 0; i < V; i++){ if(dist[i] != INT_MAX) printf("%d\t%d\n",i,dist[i]); else printf("%d\tINF",i); } } //The main function that finds the shortest path from given source //to all other vertices using Bellman-Ford.It also detects negative //weight cycle void BellmanFord(struct Graph* graph, int src){ int V = graph->vertexNum; int E = graph->edgeNum; int dist[V]; //Initialize distances array as INF for all except source //Intialize source as zero for(int i=0; i<V; i++) dist[i] = INT_MAX; dist[src] = 0; //Calculate shortest path distance from source to all edges //A path can contain maximum (|V|-1) edges for(int i=0; i<=V-1; i++) for(int j = 0; j<E; j++){ int u = graph->edges[j].src; int v = graph->edges[j].dst; int w = graph->edges[j].weight; if(dist[u]!=INT_MAX && dist[u] + w < dist[v]) dist[v] = dist[u] + w; } //Iterate inner loop once more to check for negative cycle for(int j = 0; j<E; j++){ int u = graph->edges[j].src; int v = graph->edges[j].dst; int w = graph->edges[j].weight; if(dist[u]!=INT_MAX && dist[u] + w < dist[v]){ printf("Graph contains negative weight cycle. Hence, shortest distance not guaranteed."); return; } } print(dist, V); return; } //Driver Function int main(){ int V,E,gsrc; int src,dst,weight; struct Graph G; printf("Enter number of vertices: "); scanf("%d",&V); printf("Enter number of edges: "); scanf("%d",&E); createGraph(&G,V,E); for(int i=0; i<E; i++){ printf("\nEdge %d \nEnter source: ",i+1); scanf("%d",&src); printf("Enter destination: "); scanf("%d",&dst); printf("Enter weight: "); scanf("%d",&weight); addEdge(&G, src, dst, weight); } printf("\nEnter source:"); scanf("%d",&gsrc); BellmanFord(&G,gsrc); return 0; } ``` [](https://c.algorithmexamples.com/web/data_structures/graphs/Bellman-Ford.html) [](https://c.algorithmexamples.com/web/data_structures/graphs/Bellman-Ford.html) - [](https://c.algorithmexamples.com/web/data_structures/graphs/Bellman-Ford.html) - [](https://c.algorithmexamples.com/web/data_structures/graphs/Bellman-Ford.html) - [](https://c.algorithmexamples.com/web/data_structures/graphs/Bellman-Ford.html) Copyrights © 2021 Algorithm Examples. All rights reserved. Designed by [“Art of energy from Roman Budaev”](https://c.algorithmexamples.com/web/data_structures/graphs/Bellman-Ford.html) ### LANGUAGE:  ### DARK MODE: ### PROGRAMMING LANGUAGES: [ Python](https://python.algorithmexamples.com/) [ Java](https://java.algorithmexamples.com/) [ Javascript](https://javascript.algorithmexamples.com/) [ C\#](https://csharp.algorithmexamples.com/) [ C++](https://cplusplus.algorithmexamples.com/) [ C](https://c.algorithmexamples.com/) [ Ruby](https://ruby.algorithmexamples.com/) [ Scala](https://scala.algorithmexamples.com/) [ MATLAB](https://matlab.algorithmexamples.com/) [ Kotlin](https://kotlin.algorithmexamples.com/) [ Rust](https://rust.algorithmexamples.com/) [ R](https://r.algorithmexamples.com/) [ Go](https://go.algorithmexamples.com/)