Bellman ford in Java

Java/Dynamic-Programming/edit_distance.java

@@ -36,4 +36,4 @@ public static void main(String[] args) {
         String s2 = "GEEKSFORGEEKS";
         System.out.println(editDist(s1, s2));
     }
-}
+}q

Java/Graphs/Bellman_Form_Algorithm.java

@@ -0,0 +1,125 @@
+import java.io.*;
+import java.lang.*;
+import java.util.*;
+
+class Graph {
+
+    // A class to represent a weighted edge in graph
+    class Edge {
+        int src, dest, weight;
+        Edge() { src = dest = weight = 0; }
+    };
+
+    int V, E;
+    Edge edge[];
+
+    // Creates a graph with V vertices and E edges
+    Graph(int v, int e)
+    {
+        V = v;
+        E = e;
+        edge = new Edge[e];
+        for (int i = 0; i < e; ++i)
+            edge[i] = new Edge();
+    }
+
+    void BellmanFord(Graph graph, int src)
+    {
+        int V = graph.V, E = graph.E;
+        int dist[] = new int[V];
+
+        // Step 1: Initialize distances from src to all
+        // other vertices as INFINITE
+        for (int i = 0; i < V; ++i)
+            dist[i] = Integer.MAX_VALUE;
+        dist[src] = 0;
+
+        // Step 2: Relax all edges |V| - 1 times. A simple
+        // shortest path from src to any other vertex can
+        // have at-most |V| - 1 edges
+        for (int i = 1; i < V; ++i) {
+            for (int j = 0; j < E; ++j) {
+                int u = graph.edge[j].src;
+                int v = graph.edge[j].dest;
+                int weight = graph.edge[j].weight;
+                if (dist[u] != Integer.MAX_VALUE
+                    && dist[u] + weight < dist[v])
+                    dist[v] = dist[u] + weight;
+            }
+        }
+
+        for (int j = 0; j < E; ++j) {
+            int u = graph.edge[j].src;
+            int v = graph.edge[j].dest;
+            int weight = graph.edge[j].weight;
+            if (dist[u] != Integer.MAX_VALUE
+                && dist[u] + weight < dist[v]) {
+                System.out.println(
+                    "Graph contains negative weight cycle");
+                return;
+            }
+        }
+        printArr(dist, V);
+    }
+
+    // A utility function used to print the solution
+    void printArr(int dist[], int V)
+    {
+        System.out.println("Vertex Distance from Source");
+        for (int i = 0; i < V; ++i)
+            System.out.println(i + "\t\t" + dist[i]);
+    }
+
+    // Driver's code
+    public static void main(String[] args)
+    {
+        int V = 5; // Number of vertices in graph
+        int E = 8; // Number of edges in graph
+
+        Graph graph = new Graph(V, E);
+
+        // add edge 0-1 (or A-B in above figure)
+        graph.edge[0].src = 0;
+        graph.edge[0].dest = 1;
+        graph.edge[0].weight = -1;
+
+        // add edge 0-2 (or A-C in above figure)
+        graph.edge[1].src = 0;
+        graph.edge[1].dest = 2;
+        graph.edge[1].weight = 4;
+
+        // add edge 1-2 (or B-C in above figure)
+        graph.edge[2].src = 1;
+        graph.edge[2].dest = 2;
+        graph.edge[2].weight = 3;
+
+        // add edge 1-3 (or B-D in above figure)
+        graph.edge[3].src = 1;
+        graph.edge[3].dest = 3;
+        graph.edge[3].weight = 2;
+
+        // add edge 1-4 (or B-E in above figure)
+        graph.edge[4].src = 1;
+        graph.edge[4].dest = 4;
+        graph.edge[4].weight = 2;
+
+        // add edge 3-2 (or D-C in above figure)
+        graph.edge[5].src = 3;
+        graph.edge[5].dest = 2;
+        graph.edge[5].weight = 5;
+
+        // add edge 3-1 (or D-B in above figure)
+        graph.edge[6].src = 3;
+        graph.edge[6].dest = 1;
+        graph.edge[6].weight = 1;
+
+        // add edge 4-3 (or E-D in above figure)
+        graph.edge[7].src = 4;
+        graph.edge[7].dest = 3;
+        graph.edge[7].weight = -3;
+
+          // Function call
+        graph.BellmanFord(graph, 0);
+    }
+}
+// Contributed by Aakash Hasija

README.md

@@ -178,7 +178,7 @@
 
 | No. | Algorithm Name                                                                        | Available languages                       | 
 | --- | ----------------------------------------------------------------------------------- | ------------------------------ | 
-| 1.  | Bellman Ford | [C++](https://github.com/Kumar-laxmi/Algorithms/blob/main/C%2B%2B/Graphs/Bellman_Form_Algorithm.cpp) |
+| 1.  | Bellman Ford | [C++](https://github.com/Kumar-laxmi/Algorithms/blob/main/C%2B%2B/Graphs/Bellman_Form_Algorithm.cpp), [Java](https://github.com/Kumar-laxmi/Algorithms/blob/main/Java/Graphs/Bellman_Form_Algorithm.java) |
 | 2.  | Breadth First Search(BFS) | [C](https://github.com/Kumar-laxmi/Algorithms/blob/main/C/Graphs/BreadthFirstSearch.c), [C++](https://github.com/Kumar-laxmi/Algorithms/blob/main/C%2B%2B/Graphs/BreadthFirstSearch.cpp), [Java](https://github.com/Kumar-laxmi/Algorithms/blob/main/Java/Graphs/BreadthFirstSearch.java), [Python](https://github.com/Kumar-laxmi/Algorithms/blob/main/Python/Graphs/BreadthFirstSearch.py) |
 | 3.  | Dial’s Algorithm | [C](https://github.com/Kumar-laxmi/Algorithms/blob/main/C/Graphs/dial_algorithm.c), [C++](https://github.com/Kumar-laxmi/Algorithms/blob/main/C%2B%2B/Graphs/dial_algorithm.cpp), [Java](https://github.com/Kumar-laxmi/Algorithms/blob/main/Java/Graphs/dial_algorithm.java), [Python](https://github.com/Kumar-laxmi/Algorithms/blob/main/Python/Graphs/dial_algorithm.py) |
 | 4.  | Dijkstra | [C](https://github.com/Kumar-laxmi/Algorithms/blob/main/C/Graphs/Dijkstra.c), [C++](https://github.com/Kumar-laxmi/Algorithms/blob/main/C%2B%2B/Graphs/Dijkstra.cpp), [Java](https://github.com/Kumar-laxmi/Algorithms/blob/main/Java/Graphs/Dijkstra.java), [Python](https://github.com/Kumar-laxmi/Algorithms/blob/main/Python/Graphs/Dijkstra.py) |