From 35a4bd314df190b26dc2c92a40f8d72f16f33b14 Mon Sep 17 00:00:00 2001
From: Ayush Nagar <32647423+ayushnagar123@users.noreply.github.com>
Date: Sun, 18 Mar 2018 20:52:50 +0530
Subject: [PATCH] used to find the shorthest paths among all pairs of nodes in
 a graph,

Floyd-Warshall algorithm is a procedure, which is used to find the shorthest (longest) paths among all pairs of nodes in a graph, which does not contain any cycles of negative lenght. The main advantage of Floyd-Warshall algorithm is its simplicity.
---
 Data Structures/Graphs/FloydWarshall.java | 173 ++++++++++++++++++++++
 1 file changed, 173 insertions(+)
 create mode 100644 Data Structures/Graphs/FloydWarshall.java

diff --git a/Data Structures/Graphs/FloydWarshall.java b/Data Structures/Graphs/FloydWarshall.java
new file mode 100644
index 000000000..c5cbf16d0
--- /dev/null
+++ b/Data Structures/Graphs/FloydWarshall.java	
@@ -0,0 +1,173 @@
+    import java.util.Scanner;
+
+     
+
+    public class FloydWarshall
+
+    {
+
+        private int distancematrix[][];
+
+        private int numberofvertices;
+
+        public static final int INFINITY = 999;
+
+     
+
+        public FloydWarshall(int numberofvertices)
+
+        {
+
+            distancematrix = new int[numberofvertices + 1][numberofvertices + 1];
+
+            this.numberofvertices = numberofvertices;
+
+        }
+
+     
+
+        public void floydwarshall(int adjacencymatrix[][])
+
+        {
+
+            for (int source = 1; source <= numberofvertices; source++)
+
+            {
+
+                for (int destination = 1; destination <= numberofvertices; destination++)
+
+                {
+
+                    distancematrix[source][destination] = adjacencymatrix[source][destination];
+
+                }
+
+            }
+
+     
+
+            for (int intermediate = 1; intermediate <= numberofvertices; intermediate++)
+
+            {
+
+                for (int source = 1; source <= numberofvertices; source++)
+
+                {
+
+                    for (int destination = 1; destination <= numberofvertices; destination++)
+
+                    {
+
+                        if (distancematrix[source][intermediate] + distancematrix[intermediate][destination]
+
+                             < distancematrix[source][destination])
+
+                            distancematrix[source][destination] = distancematrix[source][intermediate] 
+
+                                + distancematrix[intermediate][destination];
+
+                    }
+
+                }
+
+            }
+
+     
+
+            for (int source = 1; source <= numberofvertices; source++)
+
+                System.out.print("\t" + source);
+
+     
+
+            System.out.println();
+
+            for (int source = 1; source <= numberofvertices; source++)
+
+            {
+
+                System.out.print(source + "\t");
+
+                for (int destination = 1; destination <= numberofvertices; destination++)
+
+                {
+
+                    System.out.print(distancematrix[source][destination] + "\t");
+
+                }
+
+                System.out.println();
+
+            }
+
+        }
+
+     
+
+        public static void main(String... arg)
+
+        {
+
+            int adjacency_matrix[][];
+
+            int numberofvertices;
+
+     
+
+            Scanner scan = new Scanner(System.in);
+
+            System.out.println("Enter the number of vertices");
+
+            numberofvertices = scan.nextInt();
+
+     
+
+            adjacency_matrix = new int[numberofvertices + 1][numberofvertices + 1];
+
+            System.out.println("Enter the Weighted Matrix for the graph");
+
+            for (int source = 1; source <= numberofvertices; source++)
+
+            {
+
+                for (int destination = 1; destination <= numberofvertices; destination++)
+
+                {
+
+                    adjacency_matrix[source][destination] = scan.nextInt();
+
+                    if (source == destination)
+
+                    {
+
+                        adjacency_matrix[source][destination] = 0;
+
+                        continue;
+
+                    }
+
+                    if (adjacency_matrix[source][destination] == 0)
+
+                    {
+
+                        adjacency_matrix[source][destination] = INFINITY;
+
+                    }
+
+                }
+
+            }
+
+     
+
+            System.out.println("The Transitive Closure of the Graph");
+
+            FloydWarshall floydwarshall = new FloydWarshall(numberofvertices);
+
+            floydwarshall.floydwarshall(adjacency_matrix);
+
+            scan.close();
+
+        }
+
+    }