From 3951db7ff9c062f1542936cfe28611297eafefea Mon Sep 17 00:00:00 2001
From: stefiosif <stef8iosif@gmail.com>
Date: Sat, 3 Aug 2024 13:14:42 +0300
Subject: [PATCH] Use clang-format

---
 benchmark/algorithm_bench.cc                 |   2 +
 include/algorithm/breadth_first_search.h     |  34 +++--
 include/algorithm/decremental_reachability.h |  11 +-
 include/algorithm/dynamic_reachability.h     |   6 +-
 include/algorithm/frigioni.h                 | 143 ++++++++++---------
 include/algorithm/henzinger_king.h           |  38 +++--
 include/algorithm/italiano.h                 |  59 ++++----
 include/algorithm/king.h                     |  44 +++---
 include/algorithm/roditty_zwick.h            |  47 +++---
 include/algorithm/tarjan.h                   |  27 ++--
 include/graph/breadth_first_tree.h           |  16 +--
 include/graph/digraph.h                      |  48 +++----
 include/graph/graph.h                        |  34 ++---
 include/graph/scc.h                          |  32 ++---
 include/roditty_zwick.h                      |   4 +-
 test/decremental_reachability_test.cc        |   2 +
 test/dynamic_reachability_test.cc            |   2 +
 17 files changed, 262 insertions(+), 287 deletions(-)

diff --git a/benchmark/algorithm_bench.cc b/benchmark/algorithm_bench.cc
index 09b3a75..ee2e7fe 100644
--- a/benchmark/algorithm_bench.cc
+++ b/benchmark/algorithm_bench.cc
@@ -1,3 +1,4 @@
+
 #include <src/include/nanobench.h>
 #include <doctest/doctest.h>
 
@@ -8,6 +9,7 @@
 #include <random>
 #include <fstream>
 #include <iostream>
+#include <memory>
 
 using namespace graph;
 
diff --git a/include/algorithm/breadth_first_search.h b/include/algorithm/breadth_first_search.h
index c82441d..66e4b43 100644
--- a/include/algorithm/breadth_first_search.h
+++ b/include/algorithm/breadth_first_search.h
@@ -1,35 +1,38 @@
 #ifndef BREADTH_FIRST_SEARCH_H_
 #define BREADTH_FIRST_SEARCH_H_
 
+#include "graph/graph.h"
 #include <map>
-#include <set>
 #include <queue>
+#include <set>
 
 using namespace graph;
 
 namespace algo {
 
-template<typename T>
-class BreadthFirstSearch {
+template <typename T> class BreadthFirstSearch {
 public:
   BreadthFirstSearch() = default;
 
-  explicit BreadthFirstSearch(std::unordered_map<T, std::unordered_set<T>> adjList)
-    : adjList(adjList) {}
+  explicit BreadthFirstSearch(
+      std::unordered_map<T, std::unordered_set<T>> adjList)
+      : adjList(adjList) {}
 
   // Traverse whole graph using the BFS search, and save the tree graph
   // which is created when visiting new vertices (Breadth First Tree)
-  std::unordered_map<T, std::unordered_set<T>> execute(const T& root);
+  std::unordered_map<T, std::unordered_set<T>> execute(const T &root);
 
   // Search if target vertex exists in graph
-  bool query(const T& root, const T& target);
+  bool query(const T &root, const T &target);
+
 private:
   // Represents the graph on which the algorithm will be executed
   std::unordered_map<T, std::unordered_set<T>> adjList;
-}; 
+};
 
-template<typename T>
-std::unordered_map<T, std::unordered_set<T>> BreadthFirstSearch<T>::execute(const T& root) {
+template <typename T>
+std::unordered_map<T, std::unordered_set<T>>
+BreadthFirstSearch<T>::execute(const T &root) {
   std::unordered_map<T, std::unordered_set<T>> tree;
   std::unordered_map<T, bool> visited;
   std::queue<T> Q;
@@ -40,7 +43,7 @@ std::unordered_map<T, std::unordered_set<T>> BreadthFirstSearch<T>::execute(cons
     const auto v = Q.front();
     Q.pop();
 
-    for (const auto& u : adjList[v]) {
+    for (const auto &u : adjList[v]) {
       if (!visited[u]) {
         visited[u] = true;
         tree[v].insert(u);
@@ -52,8 +55,8 @@ std::unordered_map<T, std::unordered_set<T>> BreadthFirstSearch<T>::execute(cons
   return tree;
 }
 
-template<typename T>
-bool BreadthFirstSearch<T>::query(const T& root, const T& target) {
+template <typename T>
+bool BreadthFirstSearch<T>::query(const T &root, const T &target) {
   std::unordered_map<T, bool> visited;
   std::queue<T> Q;
   Q.push(root);
@@ -63,9 +66,10 @@ bool BreadthFirstSearch<T>::query(const T& root, const T& target) {
     const auto v = Q.front();
     Q.pop();
 
-    if (v == target) return true;
+    if (v == target)
+      return true;
 
-    for (const auto& u : adjList[v]) {
+    for (const auto &u : adjList[v]) {
       if (!visited[u]) {
         visited[u] = true;
         Q.push(u);
diff --git a/include/algorithm/decremental_reachability.h b/include/algorithm/decremental_reachability.h
index c09ffcb..2792f53 100644
--- a/include/algorithm/decremental_reachability.h
+++ b/include/algorithm/decremental_reachability.h
@@ -4,21 +4,20 @@
 #include "graph/digraph.h"
 
 namespace algo {
-
-template<typename T>
-class DecrementalReachability {
+template <typename T> class DecrementalReachability {
 public:
   virtual ~DecrementalReachability() = default;
 
   // This method is implemented and executed by all roditty and zwick
   // algorithms, it constructs the data structures used in other operations
-  virtual void init() =0;
+  virtual void init() = 0;
 
   // Answer if vertex v is reachable from vertex u
-  virtual bool query(const T& u, const T& v) =0;
+  virtual bool query(const T &u, const T &v) = 0;
 
   // Remove edge e(u,v) and maintain the transitive closure matrix
-  virtual void remove(const std::vector<std::pair<T, T>>& edges) =0;
+  virtual void remove(const std::vector<std::pair<T, T>> &edges) = 0;
+
 protected:
   Digraph<T> G;
 };
diff --git a/include/algorithm/dynamic_reachability.h b/include/algorithm/dynamic_reachability.h
index 2ce7cb8..54bb356 100644
--- a/include/algorithm/dynamic_reachability.h
+++ b/include/algorithm/dynamic_reachability.h
@@ -4,15 +4,13 @@
 #include "algorithm/decremental_reachability.h"
 
 namespace algo {
-
-template<typename T>
+template <typename T>
 class DynamicReachability : public DecrementalReachability<T> {
 
   // Insert edge e(u,v) and maintain the transitive closure matrix
-  virtual void insert(const T& c, const std::vector<T>& vertices) =0;
+  virtual void insert(const T &c, const std::vector<T> &vertices) = 0;
 };
 
-
 } // namespace algo
 
 #endif
\ No newline at end of file
diff --git a/include/algorithm/frigioni.h b/include/algorithm/frigioni.h
index 90e4c49..3adf39a 100644
--- a/include/algorithm/frigioni.h
+++ b/include/algorithm/frigioni.h
@@ -8,8 +8,7 @@
 
 namespace algo {
 
-template<typename T>
-class Frigioni : public DecrementalReachability<T> {
+template <typename T> class Frigioni : public DecrementalReachability<T> {
 public:
   Frigioni() = default;
 
@@ -20,10 +19,11 @@ public:
 
   // Execute reachability query q(u, v) from vertex u to vertex v
   // in O(1) using the transitive closure matrix
-  bool query(const T& u, const T& v) override;
+  bool query(const T &u, const T &v) override;
 
   // Delete set of edges and explicitely maintain the transitive closure
-  void remove(const std::vector<std::pair<T, T>>& edges) override;
+  void remove(const std::vector<std::pair<T, T>> &edges) override;
+
 private:
   // Transitive closure matrix, used to answer reachability queries in O(1)
   std::unordered_map<T, std::unordered_map<T, bool>> TC;
@@ -46,161 +46,162 @@ private:
   RodittyZwick<T> rodittyZwick;
 
   // Delete internal edge e(u, v)
-  void removeInternal(const T& u, const T& v);
+  void removeInternal(const T &u, const T &v);
 
   // Delete external edge e(u, v)
-  void removeExternal(const T& u, const T& v);
+  void removeExternal(const T &u, const T &v);
 
   // Repair reachability trees
   void repairTrees();
 
-  // 
-  void splitEdges(std::unordered_map<T, SCC<T>>& L, std::unordered_map<T, SCC<T>> C, const T& w);
+  //
+  void splitEdges(std::unordered_map<T, SCC<T>> &L,
+                  std::unordered_map<T, SCC<T>> C, const T &w);
 };
 
-template<typename T>
-void Frigioni<T>::init() {
+template <typename T> void Frigioni<T>::init() {
   rodittyZwick = RodittyZwick<T>(this->G);
   rodittyZwick.init();
   auto C = rodittyZwick.getComponentMap();
 
-  for (const auto& w : std::views::keys(C)) {
+  for (const auto &w : std::views::keys(C)) {
     RT[C[w]] = BreadthFirstTree<T>(this->G, w);
-    for (const auto& u : this->G.vertices()) {
-      for (const auto& v : this->G.adjList[u]) {
+    for (const auto &u : this->G.vertices()) {
+      for (const auto &v : this->G.adjList[u]) {
         if (!C[w].contains(u) && C[w].contains(v))
-          E[C[w]].inc.insert({ u, v });
+          E[C[w]].inc.insert({u, v});
         else if (C[w].contains(u) && !C[w].contains(v))
-          E[C[w]].out.insert({ u, v });
+          E[C[w]].out.insert({u, v});
         else
-          E[C[w]].in.insert({ u, v });
+          E[C[w]].in.insert({u, v});
         TC[u][v] = false;
       }
     }
   }
-  for (const auto& w : std::views::keys(C)) {
-    for (const auto& u : C[w].vertices()) {
-      for (const auto& v : RT[C[w]].vertices()) {
+  for (const auto &w : std::views::keys(C)) {
+    for (const auto &u : C[w].vertices()) {
+      for (const auto &v : RT[C[w]].vertices()) {
         TC[u][v] = true;
       }
     }
   }
 }
 
-template<typename T>
-bool Frigioni<T>::query(const T& u, const T& v) {
+template <typename T> bool Frigioni<T>::query(const T &u, const T &v) {
   return TC[u][v];
 }
 
-template<typename T>
-void Frigioni<T>::remove(const std::vector<std::pair<T, T>>& edges) {
+template <typename T>
+void Frigioni<T>::remove(const std::vector<std::pair<T, T>> &edges) {
   std::vector<std::pair<T, T>> Eint;
   std::vector<std::pair<T, T>> Eext;
 
-  for (const auto& [u, v] : edges) {
-    if (!this->G.adjList[u].contains(v)) continue;
+  for (const auto &[u, v] : edges) {
+    if (!this->G.adjList[u].contains(v))
+      continue;
 
     if (rodittyZwick.query(u, v))
-      Eint.push_back({ u, v });
+      Eint.push_back({u, v});
     else
-      Eext.push_back({ u, v });
+      Eext.push_back({u, v});
   }
-  for (const auto& [u, v] : Eint) removeInternal(u, v);
-  for (const auto& [u, v] : Eext) removeExternal(u, v);
+  for (const auto &[u, v] : Eint)
+    removeInternal(u, v);
+  for (const auto &[u, v] : Eext)
+    removeExternal(u, v);
 
   repairTrees();
 }
 
-template<typename T>
-void Frigioni<T>::removeInternal(const T& u, const T& v) {
+template <typename T> void Frigioni<T>::removeInternal(const T &u, const T &v) {
   this->G.remove(u, v);
   auto L = rodittyZwick.getComponentMap();
   rodittyZwick.remove(u, v);
   auto C = rodittyZwick.getComponentMap();
 
   if (rodittyZwick.query(u, v)) {
-    E[C[u]].in.erase({ u, v });
+    E[C[u]].in.erase({u, v});
     return;
   }
 
   if (L[u] == C[u]) {
-    E[L[u]].out.erase({ u, v });
+    E[L[u]].out.erase({u, v});
     E.erase(L[v]);
     splitEdges(L, C, v);
-  }
-  else {
-    E[L[v]].inc.erase({ u, v });
+  } else {
+    E[L[v]].inc.erase({u, v});
     E.erase(L[u]);
     splitEdges(L, C, u);
   }
 
-  for (const auto& w : std::views::keys(C)) {
-    if (!RT[C[w]].contains(v)) continue;
+  for (const auto &w : std::views::keys(C)) {
+    if (!RT[C[w]].contains(v))
+      continue;
 
     RT[C[w]].removeEdgeTo(v);
     if (E[C[v]].inc.size() > 0) {
       H[C[w]].push(v); /*h mipos C[v].id?*/
       continue;
     }
-    for (const auto& x : C[w].vertices()) {
-      for (const auto& y : C[v].vertices()) {
+    for (const auto &x : C[w].vertices()) {
+      for (const auto &y : C[v].vertices()) {
         TC[x][y] = false;
       }
     }
-    for (const auto& [a, b] : E[C[v]].out)
+    for (const auto &[a, b] : E[C[v]].out)
       H[C[w]].push(b);
   }
 }
 
-template<typename T>
-void Frigioni<T>::removeExternal(const T& u, const T& v) {
+template <typename T> void Frigioni<T>::removeExternal(const T &u, const T &v) {
   this->G.remove(u, v);
   auto C = rodittyZwick.getComponentMap();
-  E[C[v]].inc.erase({ u, v });
-  E[C[u]].out.erase({ u, v });
+  E[C[v]].inc.erase({u, v});
+  E[C[u]].out.erase({u, v});
 
-  for (const auto& w : std::views::keys(C)) {
-    if (!RT[C[w]].contains(v)) continue;
+  for (const auto &w : std::views::keys(C)) {
+    if (!RT[C[w]].contains(v))
+      continue;
 
     RT[C[w]].removeEdgeTo(v);
     if (E[C[v]].inc.size() > 0) {
       H[C[w]].push(v);
       continue;
     }
-    for (const auto& x : C[w].vertices()) {
-      for (const auto& y : C[v].vertices()) {
+    for (const auto &x : C[w].vertices()) {
+      for (const auto &y : C[v].vertices()) {
         TC[x][y] = false;
       }
     }
-    for (const auto& [a, b] : E[C[v]].out)
+    for (const auto &[a, b] : E[C[v]].out)
       H[C[w]].push(b);
   }
 }
 
-template<typename T>
-void Frigioni<T>::repairTrees() {
+template <typename T> void Frigioni<T>::repairTrees() {
   auto C = rodittyZwick.getComponentMap();
-  for (const auto& w : std::views::keys(C)) {
+  for (const auto &w : std::views::keys(C)) {
     while (H[C[w]].size() > 0) {
-      const auto& h = H[C[w]].top();
+      const auto &h = H[C[w]].top();
       H[C[w]].pop();
       bool foundHook = false;
 
-      for (const auto& [a, b] : E[C[h]].inc) {
+      for (const auto &[a, b] : E[C[h]].inc) {
         if (RT[C[w]].adjList[w].contains(a)) {
           RT[C[w]].insert(a, h);
           foundHook = true;
           break;
         }
       }
-      if (foundHook) continue;
+      if (foundHook)
+        continue;
 
-      for (const auto& x : C[w].vertices()) {
-        for (const auto& y : C[h].vertices()) {
+      for (const auto &x : C[w].vertices()) {
+        for (const auto &y : C[h].vertices()) {
           TC[x][y] = false;
         }
       }
-      for (const auto& [a, b] : E[C[h]].out) {
+      for (const auto &[a, b] : E[C[h]].out) {
         if (RT[C[w]].adjList[h].contains(a)) {
           H[C[w]].push(b);
         }
@@ -209,21 +210,21 @@ void Frigioni<T>::repairTrees() {
   }
 }
 
-template<typename T>
-void Frigioni<T>::splitEdges(std::unordered_map<T, SCC<T>>& L, std::unordered_map<T, SCC<T>> C, const T& w) {
-  for (const auto& [a, b] : E[L[w]].inc)
-    E[C[b]].inc.insert({ a, b });
+template <typename T>
+void Frigioni<T>::splitEdges(std::unordered_map<T, SCC<T>> &L,
+                             std::unordered_map<T, SCC<T>> C, const T &w) {
+  for (const auto &[a, b] : E[L[w]].inc)
+    E[C[b]].inc.insert({a, b});
 
-  for (const auto& [a, b] : E[L[w]].out)
-    E[C[a]].out.insert({ a, b });
+  for (const auto &[a, b] : E[L[w]].out)
+    E[C[a]].out.insert({a, b});
 
-  for (const auto& [a, b] : E[L[w]].in) {
+  for (const auto &[a, b] : E[L[w]].in) {
     if (C[a] == C[b]) {
-      E[C[a]].in.insert({ a, b });
-    }
-    else {
-      E[C[a]].out.insert({ a, b });
-      E[C[b]].in.insert({ a, b });
+      E[C[a]].in.insert({a, b});
+    } else {
+      E[C[a]].out.insert({a, b});
+      E[C[b]].in.insert({a, b});
     }
   }
 }
diff --git a/include/algorithm/henzinger_king.h b/include/algorithm/henzinger_king.h
index 95031a8..bfb6e0d 100644
--- a/include/algorithm/henzinger_king.h
+++ b/include/algorithm/henzinger_king.h
@@ -8,8 +8,7 @@ constexpr int threshold = 5;
 
 namespace algo {
 
-template<typename T>
-class HenzingerKing : public DynamicReachability<T> {
+template <typename T> class HenzingerKing : public DynamicReachability<T> {
 public:
   HenzingerKing() = default;
 
@@ -21,16 +20,17 @@ public:
   // Execute query q(u, v) from vertex u to vertex v by querying the
   // decremental reachability data structure at the start of the phase
   // and then if necessary check the set S
-  bool query(const T& u, const T& v) override;
+  bool query(const T &u, const T &v) override;
 
   // Remove collection of edges from the decremental maintenance data structure
   // and for every vertex in set S, rebuilt reachability trees from scratch
-  void remove(const std::vector<std::pair<T,T>>& edges);
+  void remove(const std::vector<std::pair<T, T>> &edges) override;
 
   // Insert collection of edges in set S, if threshold is reached re-initialize
   // algorithm, otherwise construct reachability trees for the vertex that is
   // the center-of-insertions
-  void insert(const T& c, const std::vector<T>& vertices);
+  void insert(const T &c, const std::vector<T> &vertices) override;
+
 private:
   // Decremental maintenance data structure
   Frigioni<T> frigioni;
@@ -43,41 +43,37 @@ private:
   std::unordered_map<T, BreadthFirstTree<T>> Out;
 };
 
-template<typename T>
-void HenzingerKing<T>::init() {
+template <typename T> void HenzingerKing<T>::init() {
   S.clear();
   frigioni = Frigioni<T>(this->G);
   frigioni.init();
 }
 
-template<typename T>
-bool HenzingerKing<T>::query(const T& u, const T& v) {
+template <typename T> bool HenzingerKing<T>::query(const T &u, const T &v) {
   if (frigioni.query(u, v))
     return true;
 
-  return std::ranges::any_of(S.begin(), S.end(),
-                     [&](const T& w) {
-                       return In[w].adjList.contains(u) &&
-                         Out[w].adjList.contains(v);
-                     });
+  return std::ranges::any_of(S.begin(), S.end(), [&](const T &w) {
+    return In[w].adjList.contains(u) && Out[w].adjList.contains(v);
+  });
 }
 
-template<typename T>
-void HenzingerKing<T>::remove(const std::vector<std::pair<T, T>>& edges) {
-  for (const auto& [u, v] : edges) {
+template <typename T>
+void HenzingerKing<T>::remove(const std::vector<std::pair<T, T>> &edges) {
+  for (const auto &[u, v] : edges) {
     this->G.remove(u, v);
   }
   frigioni.remove(edges);
 
-  for (const auto& w : S) {
+  for (const auto &w : S) {
     In[w] = BreadthFirstTree(this->G.reverse(), w);
     Out[w] = BreadthFirstTree(this->G, w);
   }
 }
 
-template<typename T>
-void HenzingerKing<T>::insert(const T& c, const std::vector<T>& vertices) {
-  for (const auto& w : vertices)
+template <typename T>
+void HenzingerKing<T>::insert(const T &c, const std::vector<T> &vertices) {
+  for (const auto &w : vertices)
     this->G.insert(c, w);
 
   S.insert(c);
diff --git a/include/algorithm/italiano.h b/include/algorithm/italiano.h
index af78723..e9eda89 100644
--- a/include/algorithm/italiano.h
+++ b/include/algorithm/italiano.h
@@ -7,8 +7,7 @@
 
 namespace algo {
 
-template<typename T>
-class Italiano : public DecrementalReachability<T> {
+template <typename T> class Italiano : public DecrementalReachability<T> {
 public:
   Italiano() = default;
 
@@ -19,17 +18,18 @@ public:
 
   // Execute reachability query q(u, v) from vertex u to vertex v
   // in O(1) using the transitive closure matrix
-  bool query(const T& u, const T& v) override;
+  bool query(const T &u, const T &v) override;
 
   // Delete collection of edges
-  void remove(const std::vector<std::pair<T, T>>& edges) override;
+  void remove(const std::vector<std::pair<T, T>> &edges) override;
 
   // Delete edge e(u, v) and explicitly maintain the transitive closure
-  void remove(const T& u, const T& v);
+  void remove(const T &u, const T &v);
+
 private:
   // Transitive closure matrix
   std::unordered_map<T, std::unordered_map<T, bool>> TC;
-  
+
   // For each vertex, store a reachability tree created as a BFS tree
   std::unordered_map<T, BreadthFirstTree<T>> RT;
 
@@ -47,42 +47,41 @@ private:
   void repairTrees();
 };
 
-template<typename T>
-void Italiano<T>::init() {
-  for (const auto& u : this->G.vertices()) {
-    for (const auto& v : this->G.adjList[u]) {
+template <typename T> void Italiano<T>::init() {
+  for (const auto &u : this->G.vertices()) {
+    for (const auto &v : this->G.adjList[u]) {
       E[v].inc.insert(u);
       E[u].out.insert(v);
       TC[u][v] = false;
     }
     RT[u] = BreadthFirstTree<T>(this->G, u);
     TC[u][u] = true;
-    for (const auto& v : RT[u].vertices())
+    for (const auto &v : RT[u].vertices())
       TC[u][v] = true;
   }
 }
 
-template<typename T>
-bool Italiano<T>::query(const T& u, const T& v) {
+template <typename T> bool Italiano<T>::query(const T &u, const T &v) {
   return TC[u][v];
 }
 
-template<typename T>
-void Italiano<T>::remove(const std::vector<std::pair<T, T>>& edges) {
-  for (const auto& [u, v] : edges) {
-    if (!this->G.adjList[u].contains(v)) continue;
+template <typename T>
+void Italiano<T>::remove(const std::vector<std::pair<T, T>> &edges) {
+  for (const auto &[u, v] : edges) {
+    if (!this->G.adjList[u].contains(v))
+      continue;
     remove(u, v);
   }
 }
 
-template<typename T>
-void Italiano<T>::remove(const T& u, const T& v) {
+template <typename T> void Italiano<T>::remove(const T &u, const T &v) {
   this->G.remove(u, v);
   E[u].out.erase(v);
   E[v].inc.erase(u);
-  
-  for (const auto& w : this->G.vertices()) {
-    if (!RT[w].adjList[u].contains(v)) continue;
+
+  for (const auto &w : this->G.vertices()) {
+    if (!RT[w].adjList[u].contains(v))
+      continue;
 
     RT[w].adjList[u].erase(v);
     if (E[v].inc.size() > 0) {
@@ -90,31 +89,31 @@ void Italiano<T>::remove(const T& u, const T& v) {
       continue;
     }
     TC[w][v] = false;
-    for (const auto& c : E[v].out)
+    for (const auto &c : E[v].out)
       H[w].push(c);
   }
   repairTrees();
 }
 
-template<typename T>
-void Italiano<T>::repairTrees() {
-  for (const auto& w : this->G.vertices()) {
+template <typename T> void Italiano<T>::repairTrees() {
+  for (const auto &w : this->G.vertices()) {
     while (H[w].size() > 0) {
-      const auto& h = H[w].top();
+      const auto &h = H[w].top();
       H[w].pop();
       bool foundHook = false;
 
-      for (const auto& i : E[h].inc) {
+      for (const auto &i : E[h].inc) {
         if (RT[w].adjList[w].contains(i)) {
           RT[w].adjList[i].insert(h);
           foundHook = true;
           break;
         }
       }
-      if (foundHook) continue;
+      if (foundHook)
+        continue;
 
       TC[w][h] = false;
-      for (const auto& o : E[h].out) {
+      for (const auto &o : E[h].out) {
         if (RT[w].adjList[h].contains(o)) {
           H[w].push(o);
         }
diff --git a/include/algorithm/king.h b/include/algorithm/king.h
index 3ffd863..a2256fd 100644
--- a/include/algorithm/king.h
+++ b/include/algorithm/king.h
@@ -6,8 +6,7 @@
 
 namespace algo {
 
-template<typename T>
-class King : public DynamicReachability<T> {
+template <typename T> class King : public DynamicReachability<T> {
 public:
   King() = default;
 
@@ -19,26 +18,26 @@ public:
 
   // Execute reachability query q(u, v) from vertex u to vertex v
   // in O(n) using the stored decremental maintenance data structure for DAGs
-  bool query(const T& u, const T& v) override;
+  bool query(const T &u, const T &v) override;
 
   // Delete collection of edges
-  void remove(const std::vector<std::pair<T, T>>& edges) override;
+  void remove(const std::vector<std::pair<T, T>> &edges) override;
 
   // Delete edge e(u, v) from all reachability trees and update each one of
   // them using the decremental reachability algorithm for DAGs
-  void remove(const T& u, const T& v);
+  void remove(const T &u, const T &v);
 
   // Insert edge e(u, v) by reconstructing all reachability trees
-  void insert(const T& c, const std::vector<T>& vertices) override;
+  void insert(const T &c, const std::vector<T> &vertices) override;
+
 private:
   // Connect each reachabiliy tree with decremental maintenance data structure
   std::unordered_map<T, Italiano<T>> In;
   std::unordered_map<T, Italiano<T>> Out;
 };
 
-template<typename T>
-void King<T>::init() {
-  for (const auto& u : this->G.vertices()) {
+template <typename T> void King<T>::init() {
+  for (const auto &u : this->G.vertices()) {
     In[u] = Italiano<T>(BreadthFirstTree<T>(this->G.reverse(), u));
     In[u].init();
     Out[u] = Italiano<T>(BreadthFirstTree<T>(this->G, u));
@@ -46,32 +45,29 @@ void King<T>::init() {
   }
 }
 
-template<typename T>
-bool King<T>::query(const T& u, const T& v) {
-  return std::ranges::any_of(this->G.vertices().begin(), this->G.vertices().end(),
-                     [&](const T& w) {
-                       return In[w].query(w, u) && Out[w].query(w, v);
-                     });
+template <typename T> bool King<T>::query(const T &u, const T &v) {
+  return std::any_of(
+      this->G.vertices().begin(), this->G.vertices().end(),
+      [&](const T &w) { return In[w].query(w, u) && Out[w].query(w, v); });
 }
 
-template<typename T>
-void King<T>::remove(const std::vector<std::pair<T, T>>& edges) {
-  for (const auto& [u, v] : edges)
+template <typename T>
+void King<T>::remove(const std::vector<std::pair<T, T>> &edges) {
+  for (const auto &[u, v] : edges)
     remove(u, v);
 }
 
-template<typename T>
-void King<T>::remove(const T& u, const T& v) {
+template <typename T> void King<T>::remove(const T &u, const T &v) {
   this->G.remove(u, v);
-  for (const auto& w : this->G.vertices()) {
+  for (const auto &w : this->G.vertices()) {
     In[w].remove(v, u);
     Out[w].remove(u, v);
   }
 }
 
-template<typename T>
-void King<T>::insert(const T& c, const std::vector<T>& vertices) {
-  for (const auto& v : vertices) {
+template <typename T>
+void King<T>::insert(const T &c, const std::vector<T> &vertices) {
+  for (const auto &v : vertices) {
     this->G.insert(c, v);
   }
   In[c] = Italiano<T>(BreadthFirstTree<T>(this->G.reverse(), c));
diff --git a/include/algorithm/roditty_zwick.h b/include/algorithm/roditty_zwick.h
index 4b83c2c..d957729 100644
--- a/include/algorithm/roditty_zwick.h
+++ b/include/algorithm/roditty_zwick.h
@@ -7,8 +7,7 @@
 
 namespace algo {
 
-template<typename T>
-class RodittyZwick : public DecrementalReachability<T> {
+template <typename T> class RodittyZwick : public DecrementalReachability<T> {
 public:
   RodittyZwick() = default;
 
@@ -21,15 +20,16 @@ public:
   void findSCC(graph::Digraph<T> G);
 
   // Return true if u and v are in the same SCC
-  bool query(const T& u, const T& v) override;
+  bool query(const T &u, const T &v) override;
 
   // Delete collection of edges
-  void remove(const std::vector<std::pair<T, T>>& edges) override;
+  void remove(const std::vector<std::pair<T, T>> &edges) override;
 
   // Remove edge (u,v) and update A accordingly for fast checking query
-  void remove(const T& u, const T& v);
+  void remove(const T &u, const T &v);
 
   std::unordered_map<T, SCC<T>> getComponentMap() { return C; }
+
 private:
   // Array used to answer strong connectivity queries in O(1) time
   std::unordered_map<T, T> A;
@@ -42,21 +42,17 @@ private:
   std::unordered_map<T, BreadthFirstTree<T>> Out;
 };
 
-template<typename T>
-void RodittyZwick<T>::init() {
-  findSCC(this->G);
-}
+template <typename T> void RodittyZwick<T>::init() { findSCC(this->G); }
 
-template<typename T>
-void RodittyZwick<T>::findSCC(graph::Digraph<T> G) {
+template <typename T> void RodittyZwick<T>::findSCC(graph::Digraph<T> G) {
   auto SCCs = Tarjan<T>(G.adjList).execute();
-  
-  for (auto& c : SCCs) {
-    const auto& w = c.id;
 
-    for (const auto& v : c.vertices())
+  for (auto &c : SCCs) {
+    const auto &w = c.id;
+
+    for (const auto &v : c.vertices())
       A[v] = w;
-    
+
     Out[w] = BreadthFirstTree<T>(c, w);
     In[w] = BreadthFirstTree<T>(c.reverse(), w);
 
@@ -64,20 +60,18 @@ void RodittyZwick<T>::findSCC(graph::Digraph<T> G) {
   }
 }
 
-template<typename T>
-bool RodittyZwick<T>::query(const T& u, const T& v) {
+template <typename T> bool RodittyZwick<T>::query(const T &u, const T &v) {
   return A[u] == A[v];
 }
 
-template<typename T>
-void RodittyZwick<T>::remove(const std::vector<std::pair<T, T>>& edges) {
-  for (const auto& [u, v] : edges)
+template <typename T>
+void RodittyZwick<T>::remove(const std::vector<std::pair<T, T>> &edges) {
+  for (const auto &[u, v] : edges)
     remove(u, v);
 }
 
-template<typename T>
-void RodittyZwick<T>::remove(const T& u, const T& v) {
-  const auto& w = A[u];
+template <typename T> void RodittyZwick<T>::remove(const T &u, const T &v) {
+  const auto &w = A[u];
   C[w].remove(u, v);
   this->G.remove(u, v);
 
@@ -85,8 +79,9 @@ void RodittyZwick<T>::remove(const T& u, const T& v) {
   if (A[u] != A[v])
     return;
 
-  // If edge (u,v) is not contained in both inTree and outTree do nothing TODO:remove useless comments
-  // is this not better if i utilize A matrix, since we are going traversing between components.. ? TODO
+  // If edge (u,v) is not contained in both inTree and outTree do nothing
+  // TODO:remove useless comments is this not better if i utilize A matrix,
+  // since we are going traversing between components.. ? TODO
   if (!In[w].adjList[u].contains(v) && !Out[w].adjList[u].contains(v))
     return;
 
diff --git a/include/algorithm/tarjan.h b/include/algorithm/tarjan.h
index a3452bb..ff047c9 100644
--- a/include/algorithm/tarjan.h
+++ b/include/algorithm/tarjan.h
@@ -3,24 +3,25 @@
 
 #include "graph/scc.h"
 
+#include <ranges>
 #include <stack>
 #include <vector>
-#include <ranges>
 
 namespace algo {
 
-template<typename T>
-class Tarjan {
+template <typename T> class Tarjan {
 public:
   Tarjan() = default;
 
-  explicit Tarjan(std::unordered_map<T, std::unordered_set<T>> adjList) : adjList(adjList) {}
+  explicit Tarjan(std::unordered_map<T, std::unordered_set<T>> adjList)
+      : adjList(adjList) {}
 
   //
   auto execute();
-  
+
   //
-  void strongConnect(const T& u);
+  void strongConnect(const T &u);
+
 private:
   std::unordered_map<T, std::unordered_set<T>> adjList;
   std::stack<T> S;
@@ -36,13 +37,12 @@ private:
   std::unordered_map<T, Vertex> V;
 };
 
-template<typename T>
-void Tarjan<T>::strongConnect(const T& u) {
+template <typename T> void Tarjan<T>::strongConnect(const T &u) {
   V[u].index = V[u].lowlink = index++;
   S.push(u);
   V[u].onStack = true;
 
-  for (const auto& w : adjList[u]) {
+  for (const auto &w : adjList[u]) {
     if (V[w].index == -1) {
       strongConnect(w);
       V[u].lowlink = std::min(V[u].lowlink, V[w].lowlink);
@@ -64,14 +64,13 @@ void Tarjan<T>::strongConnect(const T& u) {
       scc[w] = adjList[w];
       finished = (w == u);
     } while (!finished);
-    
-    SCCs.push_back({ scc, static_cast<T>(cid) });
+
+    SCCs.push_back({scc, static_cast<T>(cid)});
   }
 }
 
-template<typename T>
-auto Tarjan<T>::execute() {
-  for (const auto& u : std::views::keys(adjList)) {
+template <typename T> auto Tarjan<T>::execute() {
+  for (const auto &u : std::views::keys(adjList)) {
     if (V[u].index == -1)
       strongConnect(u);
   }
diff --git a/include/graph/breadth_first_tree.h b/include/graph/breadth_first_tree.h
index 197157c..cabfb56 100644
--- a/include/graph/breadth_first_tree.h
+++ b/include/graph/breadth_first_tree.h
@@ -5,30 +5,28 @@
 
 namespace graph {
 
-template<typename T>
-class BreadthFirstTree : public Digraph<T> {
+template <typename T> class BreadthFirstTree : public Digraph<T> {
 public:
   BreadthFirstTree() = default;
 
   BreadthFirstTree(std::unordered_map<T, std::unordered_set<T>> G, T root)
-    : BreadthFirstTree<T>(Digraph<T>(G), root) {}
+      : BreadthFirstTree<T>(Digraph<T>(G), root) {}
 
   BreadthFirstTree(Digraph<T> G, T root);
 
-  void removeEdgeTo(const T& u);
+  void removeEdgeTo(const T &u);
 
   T root{};
 };
 
-template<typename T>
+template <typename T>
 BreadthFirstTree<T>::BreadthFirstTree(Digraph<T> G, T root) {
   this->adjList = algo::BreadthFirstSearch<T>(G.adjList).execute(root);
 }
 
-template<typename T>
-void BreadthFirstTree<T>::removeEdgeTo(const T& u) {
-  for (const auto& x : this->vertices()) {
-    for (const auto& y : this->adjList[x]) {
+template <typename T> void BreadthFirstTree<T>::removeEdgeTo(const T &u) {
+  for (const auto &x : this->vertices()) {
+    for (const auto &y : this->adjList[x]) {
       if (y == u) {
         this->remove(x, u);
         return;
diff --git a/include/graph/digraph.h b/include/graph/digraph.h
index 9a88d98..00119bf 100644
--- a/include/graph/digraph.h
+++ b/include/graph/digraph.h
@@ -1,64 +1,59 @@
 #ifndef DIGRAPH_H_
 #define DIGRAPH_H_
 
-#include "graph.h"
 #include "algorithm/breadth_first_search.h"
+#include "graph.h"
 
 namespace graph {
 
-template<typename T>
-class Digraph : public Graph<T> {
+template <typename T> class Digraph : public Graph<T> {
 public:
   Digraph() = default;
 
   explicit Digraph(std::unordered_map<T, std::unordered_set<T>> G);
 
   // Return true if there is a path from u to v
-  bool contains(const T& u, const T& v);
+  bool contains(const T &u, const T &v);
 
   // Add edge e(u,v)
-  void insert(const T& u, const T& v);
+  void insert(const T &u, const T &v);
 
   // Remove edge e(u,v)
-  void remove(const T& u, const T& v);
+  void remove(const T &u, const T &v);
 
   // Reverse graph directions
   auto reverse();
 
   //
-  auto contains(const T& u);
-
-  friend std::ostream& operator<<<>(std::ostream& os, Digraph<T>& G);
+  auto contains(const T &u);
 
+  template <typename U>
+  friend std::ostream &operator<<(std::ostream &os, const Digraph<U> &G);
 };
 
-template<typename T>
+template <typename T>
 Digraph<T>::Digraph(std::unordered_map<T, std::unordered_set<T>> G) {
   this->adjList = G;
 }
 
-template<typename T>
-bool Digraph<T>::contains(const T& u, const T& v) {
+template <typename T> bool Digraph<T>::contains(const T &u, const T &v) {
   return algo::BreadthFirstSearch<T>(this->adjList).query(u, v);
 }
 
-template<typename T>
-void Digraph<T>::insert(const T& u, const T& v) {
+template <typename T> void Digraph<T>::insert(const T &u, const T &v) {
   this->adjList[u].insert(v);
   this->adjList[v];
 }
 
-template<typename T>
-void Digraph<T>::remove(const T& u, const T& v) {
+template <typename T> void Digraph<T>::remove(const T &u, const T &v) {
   this->adjList[u].erase(v);
 }
 
-template<typename T>
-auto Digraph<T>::reverse() {
+template <typename T> auto Digraph<T>::reverse() {
   std::unordered_map<T, std::unordered_set<T>> revMatrix;
-  
-  for (const auto& u : this->vertices()) {
-    for (const auto& v : this->adjList[u]) {
+
+  for (const auto &u : this->vertices()) {
+    for (const auto &v : this->adjList[u]) {
       revMatrix[v].insert(u);
     }
   }
@@ -66,17 +61,16 @@ auto Digraph<T>::reverse() {
   return revMatrix;
 }
 
-template<typename T>
-auto Digraph<T>::contains(const T& u) {
+template <typename T> auto Digraph<T>::contains(const T &u) {
   return this->adjList.count(u);
 }
 
-template<typename T>
-std::ostream& operator<<(std::ostream& os, Digraph<T>& G) {
+template <typename T>
+std::ostream &operator<<(std::ostream &os, Digraph<T> &G) {
   os << "V: " << G.V() << " E: " << G.E() << '\n';
-  for (const auto& u : G.vertices()) {
+  for (const auto &u : G.vertices()) {
     if (!G.adjList[u].empty()) {
-      for (const auto& v : G.adjList[u]) {
+      for (const auto &v : G.adjList[u]) {
         os << u << "->" << v << ' ';
       }
       os << '\n';
diff --git a/include/graph/graph.h b/include/graph/graph.h
index 1058bfd..fca956a 100644
--- a/include/graph/graph.h
+++ b/include/graph/graph.h
@@ -1,30 +1,29 @@
 #ifndef GRAPH_H_
 #define GRAPH_H_
 
-#include <unordered_map>
-#include <unordered_set>
 #include <ostream>
 #include <ranges>
+#include <unordered_map>
+#include <unordered_set>
 
 namespace graph {
 
 // Forward declerations
-template<typename T> class Graph;
-template<typename T> std::ostream& operator<<(std::ostream& os, Graph<T>& G);
+template <typename T> class Graph;
+template <typename T> std::ostream &operator<<(std::ostream &os, Graph<T> &G);
 
-template<typename T>
-class Graph {
+template <typename T> class Graph {
 public:
   virtual ~Graph() = default;
-  
+
   // Return true if there is a path from u to v
-  virtual bool contains(const T& u, const T& v) =0;
+  virtual bool contains(const T &u, const T &v) = 0;
 
   // Add edge e(u,v)
-  virtual void insert(const T& u, const T& v) =0;
+  virtual void insert(const T &u, const T &v) = 0;
 
   // Remove edge e(u,v)
-  virtual void remove(const T& u, const T& v) =0;
+  virtual void remove(const T &u, const T &v) = 0;
 
   // Return graph vertices
   auto vertices() const;
@@ -37,31 +36,24 @@ public:
 
   // Adjacency matrix representation
   std::unordered_map<T, std::unordered_set<T>> adjList;
-
 };
 
-template<typename T>
-auto Graph<T>::vertices() const{
+template <typename T> auto Graph<T>::vertices() const {
   return std::views::keys(adjList);
 }
 
-template<typename T>
-std::uint16_t Graph<T>::V() {
+template <typename T> std::uint16_t Graph<T>::V() {
   return static_cast<std::uint16_t>(adjList.size());
 }
 
-template<typename T>
-std::uint16_t Graph<T>::E() {
+template <typename T> std::uint16_t Graph<T>::E() {
   std::uint16_t edges = 0;
-  for (const auto& u : vertices()) {
+  for (const auto &u : vertices()) {
     edges += static_cast<std::uint16_t>(adjList[u].size());
   }
   return edges;
 }
 
-
-
 } // namespace graph
 
-
 #endif
\ No newline at end of file
diff --git a/include/graph/scc.h b/include/graph/scc.h
index d1878a2..bb45afd 100644
--- a/include/graph/scc.h
+++ b/include/graph/scc.h
@@ -8,35 +8,36 @@
 
 namespace graph {
 
-template<typename T>
-class SCC : public Digraph<T> {
+template <typename T> class SCC : public Digraph<T> {
 public:
   SCC() = default;
 
   SCC(std::unordered_map<T, std::unordered_set<T>> G, T id)
-    : Digraph<T>(G), id(id) { normalize(); }
+      : Digraph<T>(G), id(id) {
+    normalize();
+  }
 
   SCC(Digraph<T> G, T id) : id(id) { normalize(); }
 
   // Return true if u is part of this SCC
-  bool contains(const T& u) const;
+  bool contains(const T &u) const;
 
   // Representative vertex of this SCC
   T id{};
 
-  // 
+  //
   std::unordered_map<T, std::unordered_set<T>> neighboorList;
 
-  bool operator==(const SCC& o) const;
+  bool operator==(const SCC &o) const;
+
 private:
   // Erase all edges that include vertices outside this SCC
   void normalize();
 };
 
-template<typename T>
-void SCC<T>::normalize() {
-  for (const auto& u : this->vertices()) {
-    for (const auto& v : this->adjList[u]) {
+template <typename T> void SCC<T>::normalize() {
+  for (const auto &u : this->vertices()) {
+    for (const auto &v : this->adjList[u]) {
       if (!this->contains(v)) {
         this->adjList[u].erase(v);
         this->adjList.erase(v);
@@ -46,19 +47,16 @@ void SCC<T>::normalize() {
   }
 }
 
-template<typename T>
-bool SCC<T>::contains(const T& u) const {
+template <typename T> bool SCC<T>::contains(const T &u) const {
   return this->adjList.count(u);
 }
 
-template<typename T>
-bool SCC<T>::operator==(const SCC& o) const {
+template <typename T> bool SCC<T>::operator==(const SCC &o) const {
   return id == o.id;
 }
 
-template<typename T>
-struct HashSCC {
-  std::size_t operator()(const SCC<T>& C) const {
+template <typename T> struct HashSCC {
+  std::size_t operator()(const SCC<T> &C) const {
     return static_cast<std::size_t>(C.id);
   }
 };
diff --git a/include/roditty_zwick.h b/include/roditty_zwick.h
index b95e149..b03786b 100644
--- a/include/roditty_zwick.h
+++ b/include/roditty_zwick.h
@@ -1,9 +1,9 @@
 #ifndef RODITTY_ZWICK_H_
 #define RODITTY_ZWICK_H_
 
-#include "algorithm/italiano.h"
 #include "algorithm/frigioni.h"
-#include "algorithm/king.h"
 #include "algorithm/henzinger_king.h"
+#include "algorithm/italiano.h"
+#include "algorithm/king.h"
 
 #endif
diff --git a/test/decremental_reachability_test.cc b/test/decremental_reachability_test.cc
index d7a4992..de436e1 100644
--- a/test/decremental_reachability_test.cc
+++ b/test/decremental_reachability_test.cc
@@ -4,6 +4,8 @@
 #include "algorithm/frigioni.h"
 #include "algorithm/italiano.h"
 
+#include <memory>
+
 using namespace graph;
 
 TEST_SUITE("Decremental Reachability Test") {
diff --git a/test/dynamic_reachability_test.cc b/test/dynamic_reachability_test.cc
index d045619..36c63df 100644
--- a/test/dynamic_reachability_test.cc
+++ b/test/dynamic_reachability_test.cc
@@ -3,6 +3,8 @@
 #include "algorithm/henzinger_king.h"
 #include "algorithm/king.h"
 
+#include <memory>
+
 using namespace graph;
 
 TEST_SUITE("Dynamic Reachability Test") {