Add Floyd Warshall Algorithm (#243)

Author: NimrodRak

Algorithms.Tests/Graph/FloydWarshallTests.cs

@@ -0,0 +1,57 @@
+using Algorithms.Graph;
+using DataStructures.Graph;
+using NUnit.Framework;
+using FluentAssertions;
+
+namespace Algorithms.Tests.Graph
+{
+    public class FloydWarshallTests
+    {
+        [Test]
+        public void CorrectMatrixTest()
+        {
+            var graph = new DirectedWeightedGraph<int>(10);
+
+            var vertex1 = graph.AddVertex(1);
+
+            var vertex2 = graph.AddVertex(2);
+
+            var vertex3 = graph.AddVertex(3);
+
+            var vertex4 = graph.AddVertex(4);
+
+            var vertex5 = graph.AddVertex(5);
+
+            graph.AddEdge(vertex1, vertex2, 3);
+
+            graph.AddEdge(vertex1, vertex5, -4);
+
+            graph.AddEdge(vertex1, vertex3, 8);
+
+            graph.AddEdge(vertex2, vertex5, 7);
+
+            graph.AddEdge(vertex2, vertex4, 1);
+
+            graph.AddEdge(vertex3, vertex2, 4);
+
+            graph.AddEdge(vertex4, vertex3, -5);
+
+            graph.AddEdge(vertex4, vertex1, 2);
+
+            graph.AddEdge(vertex5, vertex4, 6);
+
+            var actualDistances = new double[,]
+            {
+                { 0, 1, -3, 2, -4 },
+                { 3, 0, -4, 1, -1 },
+                { 7, 4, 0, 5, 3 },
+                { 2, -1, -5, 0, -2 },
+                { 8, 5, 1, 6, 0 }
+            };
+
+            var floydWarshaller = new FloydWarshall<int>();
+
+            floydWarshaller.Run(graph).Should().Equal(actualDistances);
+        }
+    }
+}

Algorithms/Graph/FloydWarshall.cs

@@ -0,0 +1,65 @@
+using System;
+using DataStructures.Graph;
+
+namespace Algorithms.Graph
+{
+    /// <summary>
+    /// Floyd Warshall algorithm on directed weighted graph.
+    /// </summary>
+    /// <typeparam name="T">generic type of data in graph.</typeparam>
+    public class FloydWarshall<T>
+    {
+        /// <summary>
+        /// runs the algorithm.
+        /// </summary>
+        /// <param name="graph">graph upon which to run.</param>
+        /// <returns>
+        /// a 2D array of shortest paths between any two vertices.
+        /// where there is no path between two vertices - double.PositiveInfinity is placed.
+        /// </returns>
+        public double[,] Run(DirectedWeightedGraph<T> graph)
+        {
+            var distances = SetupDistances(graph);
+            var vertexCount = distances.GetLength(0);
+            for (var k = 0; k < vertexCount; k++)
+            {
+                for (var i = 0; i < vertexCount; i++)
+                {
+                    for (var j = 0; j < vertexCount; j++)
+                    {
+                        distances[i, j] = distances[i, j] > distances[i, k] + distances[k, j]
+                        ? distances[i, k] + distances[k, j]
+                        : distances[i, j];
+                    }
+                }
+            }
+
+            return distances;
+        }
+
+        /// <summary>
+        /// setup adjacency matrix for use by main algorithm run.
+        /// </summary>
+        /// <param name="graph">graph to dissect adjacency matrix from.</param>
+        /// <returns>the adjacency matrix in the format mentioned in Run.</returns>
+        private double[,] SetupDistances(DirectedWeightedGraph<T> graph)
+        {
+            var distances = new double[graph.Count, graph.Count];
+            for (int i = 0; i < distances.GetLength(0); i++)
+            {
+                for (var j = 0; j < distances.GetLength(0); j++)
+                {
+                    var dist = graph.AdjacentDistance(graph.Vertices[i] !, graph.Vertices[j] !);
+                    distances[i, j] = dist != 0 ? dist : double.PositiveInfinity;
+                }
+            }
+
+            for (var i = 0; i < distances.GetLength(0); i++)
+            {
+                distances[i, i] = 0;
+            }
+
+            return distances;
+        }
+    }
+}

DataStructures/Graph/DirectedWeightedGraph.cs

@@ -142,6 +142,22 @@ public bool AreAdjacent(Vertex<T> startVertex, Vertex<T> endVertex)
             return adjacencyMatrix[startVertex.Index, endVertex.Index] != 0;
         }
 
+        /// <summary>
+        /// Return the distance between two vertices in the graph.
+        /// </summary>
+        /// <param name="startVertex">first vertex in edge.</param>
+        /// <param name="endVertex">secnod vertex in edge.</param>
+        /// <returns>distance between the two.</returns>
+        public double AdjacentDistance(Vertex<T> startVertex, Vertex<T> endVertex)
+        {
+            if (AreAdjacent(startVertex, endVertex))
+            {
+                return adjacencyMatrix[startVertex.Index, endVertex.Index];
+            }
+
+            return 0;
+        }
+
         private static void ThrowIfNegativeCapacity(int capacity)
         {
             if (capacity < 0)

DataStructures/Graph/IDirectedWeightedGraph.cs

@@ -14,6 +14,8 @@ public interface IDirectedWeightedGraph<T>
 
         bool AreAdjacent(Vertex<T> startVertex, Vertex<T> endVertex);
 
+        double AdjacentDistance(Vertex<T> startVertex, Vertex<T> endVertex);
+
         IEnumerable<Vertex<T>?> GetNeighbors(Vertex<T> vertex);
 
         void RemoveEdge(Vertex<T> startVertex, Vertex<T> endVertex);