Floyd-Warshall algorithm

docs/docs/algorithms/shortest-path/floyd-warshall.md

@@ -0,0 +1,30 @@
+---
+sidebar_position: 5
+---
+
+# Floyd-Warshall algorithm
+
+Floyd-Warshall algorithm computes the shortest path between any two vertices in a graph, both directed and undirected.
+The algorithm does not work for graphs with negative weight cycles.
+The key idea of the algorithm is to relax the weighted shortest path between any two vertices, using any vertex as an
+intermediate one.
+Advantage of the algorithm is that it processes vertices instead of edges. This advantage can be used when the number of
+edges is large enough, aka a dense graph.
+Runtime of the algorithm is O(|V<sup>3</sup>|) and memory consumption is O(|V<sup>2</sup>|).
+
+[wikipedia](https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm)
+
+## Syntax
+
+Calculates the shortest path between any two vertices.
+
+```cpp
+template <typename V, typename E, graph_type T,
+          typename WEIGHT_T = decltype(get_weight(std::declval<E>()))>
+std::vector<std::vector<WEIGHT_T>> floyd_warshall_shortest_paths(
+    const graph<V, E, T>& graph);
+```
+
+- **graph** The graph to extract the shortest path from.
+- **return** Returns a 2D vector of the shortest path. If a path doesn't exist between two vertices, mark it as
+  TYPE_MAX.

include/graaflib/algorithm/shortest_path/floyd_warshall.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <graaflib/graph.h>
+#include <graaflib/types.h>
+
+namespace graaf::algorithm {
+/**
+ * @brief Floyd-Warshall Algorithm
+ *
+ * This function computes the shortest paths between all pairs of vertices in a
+ * given weighted graph. It works for graphs with negative weight edges as well,
+ * but not for graphs with negative weight cycles. The function returns an
+ * adjacency matrix representing the shortest distances.
+ *
+ * @tparam V The type of a graph vertex
+ * @tparam E The type of a graph edge
+ * @tparam T the graph type (DIRECTED or UNDIRECTED)
+ * @tparam WEIGHT_T The weight type of an edge in the graph
+ * @param graph The graph object
+ * @return A 2D vector where element at [i][j] is the shortest distance from
+ * vertex i to vertex j.
+ */
+template <typename V, typename E, graph_type T,
+          typename WEIGHT_T = decltype(get_weight(std::declval<E>()))>
+std::vector<std::vector<WEIGHT_T>> floyd_warshall_shortest_paths(
+    const graph<V, E, T>& graph);
+
+};  // namespace graaf::algorithm
+
+#include "floyd_warshall.tpp"

include/graaflib/algorithm/shortest_path/floyd_warshall.tpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <graaflib/algorithm/shortest_path/floyd_warshall.h>
+
+#include <limits>
+#include <vector>
+
+namespace graaf::algorithm {
+
+template <typename V, typename E, graph_type T, typename WEIGHT_T>
+std::vector<std::vector<WEIGHT_T>> floyd_warshall_shortest_paths(
+    const graph<V, E, T>& graph) {
+  WEIGHT_T ZERO{};
+  std::size_t n = graph.vertex_count();
+  auto INF = std::numeric_limits<WEIGHT_T>::max();
+
+  std::vector<std::vector<WEIGHT_T>> shortest_paths(
+      n, std::vector<WEIGHT_T>(n, INF));
+
+  for (std::size_t vertex = 0; vertex < n; ++vertex) {
+    shortest_paths[vertex][vertex] = ZERO;
+  }
+
+  // Initial weights between vertices
+  for (std::size_t from_vertex = 0; from_vertex < n; ++from_vertex) {
+    for (const auto& to_vertex : graph.get_neighbors(from_vertex)) {
+      shortest_paths[from_vertex][to_vertex] =
+          std::min(shortest_paths[from_vertex][to_vertex],
+                   get_weight(graph.get_edge(from_vertex, to_vertex)));
+    }
+  }
+
+  for (std::size_t through_vertex = 0; through_vertex < n; ++through_vertex) {
+    for (std::size_t start_vertex = 0; start_vertex < n; ++start_vertex) {
+      if (shortest_paths[start_vertex][through_vertex] < INF) {
+        for (std::size_t end_vertex = 0; end_vertex < n; ++end_vertex) {
+          if (shortest_paths[through_vertex][end_vertex] < INF) {
+            shortest_paths[start_vertex][end_vertex] =
+                std::min(shortest_paths[start_vertex][end_vertex],
+                         shortest_paths[start_vertex][through_vertex] +
+                             shortest_paths[through_vertex][end_vertex]);
+          }
+        }
+      }
+    }
+  }
+
+  return shortest_paths;
+}
+
+};  // namespace graaf::algorithm