Improve readability

include/algorithm/breadth_first_search.h

@@ -14,7 +14,7 @@ class BreadthFirstSearch {
 public:
   BreadthFirstSearch() = default;
 
-  BreadthFirstSearch(std::unordered_map<T, std::unordered_set<T>> 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

include/algorithm/frigioni.h

@@ -29,7 +29,7 @@ private:
   std::unordered_map<T, std::unordered_map<T, bool>> TC;
 
   // For each SCC, store a reachability tree created as a BFS tree
-  std::unordered_map<T, BreadthFirstTree<T>> RT;
+  std::unordered_map<SCC<T>, BreadthFirstTree<T>, HashSCC<T>> RT;
 
   // For each SCC, store collections of incoming, outgoing and internal edges
   struct Edges {
@@ -37,37 +37,50 @@ private:
     std::set<std::pair<T, T>> inc;
     std::set<std::pair<T, T>> out;
   };
-  std::unordered_map<T, Edges> E;
-  
+  std::unordered_map<SCC<T>, Edges, HashSCC<T>> E;
+
+  // Structure that keeps candidate components to use as a hook
+  std::unordered_map<SCC<T>, std::stack<T>, HashSCC<T>> H;
+
   // Decremental maintenance of strongly connected components
   RodittyZwick<T> rodittyZwick;
+
+  // Delete internal edge e(u, v)
+  void removeInternal(const T& u, const T& v);
+
+  // Delete external edge e(u, 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);
 };
 
 template<typename T>
 void Frigioni<T>::init() {
-  auto SCCs = Tarjan<T>(this->G.adjList).execute();
   rodittyZwick = RodittyZwick<T>(this->G);
   rodittyZwick.init();
+  auto C = rodittyZwick.getComponentMap();
 
-  for (auto& scc : SCCs) {
-    RT[scc.id] = BreadthFirstTree<T>(this->G, scc.id);
+  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]) {
-        if (scc.member(u)) {
-          if (scc.member(v))
-            E[scc.id].in.insert(std::make_pair(u, v));  
-          else
-            E[scc.id].out.insert(std::make_pair(u, v));
-        } else if (scc.member(v)) {
-          E[scc.id].inc.insert(std::make_pair(u, v));
-        }
+        if (!C[w].contains(u) && C[w].contains(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 });
+        else
+          E[C[w]].in.insert({ u, v });
         TC[u][v] = false;
       }
     }
   }
-  for (auto& scc : SCCs) {
-    for (const auto& u : scc.vertices()) {
-      for (const auto& v : RT[scc.id].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;
       }
     }
@@ -85,104 +98,132 @@ void Frigioni<T>::remove(const std::vector<std::pair<T, T>>& edges) {
   std::vector<std::pair<T, T>> Eext;
 
   for (const auto& [u, v] : edges) {
+    if (!this->G.adjList[u].contains(v)) continue;
+
     if (rodittyZwick.query(u, v))
       Eint.push_back({ u, v });
     else
       Eext.push_back({ u, v });
   }
+  for (const auto& [u, v] : Eint) removeInternal(u, v);
+  for (const auto& [u, v] : Eext) removeExternal(u, v);
 
-  std::unordered_map<T, std::stack<T>> H;
-  for (const auto& [u, v] : Eint) {
-    this->G.remove(u, v);
-    rodittyZwick.remove(u, v);
+  repairTrees();
+}
 
-    if (!rodittyZwick.query(u, v)) {
-      TC[u][v] = false;
-      auto C = rodittyZwick.getSCCs();
+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();
 
-      E[C[u].id].inc.erase({ u, v });
-      E[C[u].id].out.erase({ u, v });
-      E[C[u].id].in.erase({ u, v });
-      auto D = E[C[u].id];
-      E.erase(C[u].id);
-
-      for (const auto& id : std::views::keys(C)) {
-        if (RT[id].contains(id, v)) {
-          if (E[C[v].id].inc.size() > 1)
-            H[id].push(C[v].id);
-          else {
-            for (const auto& w : C[id].vertices())
-              TC[w][v] = false;
-            for (const auto& c : E[v].out)
-              H[id].push(C[c.second].id);
-          }
-          RT[id].adjList[u].erase(v);
-        }
-      }
-
-      for (const auto& [w, z] : D.inc) {
-        E[C[z].id].inc.insert({ w, z });
-      }
-
-      for (const auto& [w, z] : D.out) {
-        E[C[w].id].out.insert({ w, z });
-      }
-
-      for (const auto& [w, z] : D.in) {
-        if (C[w] == C[z])
-          E[C[w].id].in.insert({ w, z });
-        else {
-          E[C[w].id].out.insert({ w, z });
-          E[C[z].id].in.insert({ w, z });
-        }
-      }
-    } else {
-      E[u].in.erase({ u, v });
-    }
+  if (rodittyZwick.query(u, v)) {
+    E[C[u]].in.erase({ u, v });
+    return;
   }
 
-  for (const auto& [u, v] : Eext) {
-    this->G.remove(u, v);
-    auto C = rodittyZwick.getSCCs();
-
-    for (const auto& id : std::views::keys(C)) {
-      if (RT[id].contains(id, v)) {
-        if (E[C[v].id].inc.size() > 1)
-          H[id].push(C[v].id);
-        else {
-          for (const auto& w : C[id].vertices())
-            TC[w][v] = false;
-          for (const auto& c : E[v].out)
-            H[id].push(C[c.second].id);
-        }
-        RT[id].adjList[u].erase(v);
-      }
-    }
+  if (L[u] == C[u]) {
+    E[L[u]].out.erase({ u, v });
+    E.erase(L[v]);
+    splitEdges(L, C, v);
+  }
+  else {
+    E[L[v]].inc.erase({ u, v });
+    E.erase(L[u]);
+    splitEdges(L, C, u);
   }
 
-  auto C = rodittyZwick.getSCCs();
-  for (const auto& id : std::views::keys(rodittyZwick.getSCCs())) {
-    while (H[id].size() > 0) {
-      const auto& h = H[id].top();
-      bool found = false;
-      
-      for (const auto& [u, v] : E[h].inc) {
-        if (RT[id].contains(id, u)) {
-          RT[id].adjList[u].insert(h);
-          found = true;
+  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()) {
+        TC[x][y] = false;
+      }
+    }
+    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) {
+  this->G.remove(u, v);
+  auto C = rodittyZwick.getComponentMap();
+  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;
+
+    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()) {
+        TC[x][y] = false;
+      }
+    }
+    for (const auto& [a, b] : E[C[v]].out)
+      H[C[w]].push(b);
+  }
+}
+
+template<typename T>
+void Frigioni<T>::repairTrees() {
+  auto C = rodittyZwick.getComponentMap();
+  for (const auto& w : std::views::keys(C)) {
+    while (H[C[w]].size() > 0) {
+      const auto& h = H[C[w]].top();
+      H[C[w]].pop();
+      bool foundHook = false;
+
+      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;
         }
       }
-      H[id].pop();
-      if (!found) {
-        auto C = rodittyZwick.getSCCs();
-        for (const auto& w : C[id].vertices())
-          TC[w][h] = false;
+      if (foundHook) continue;
 
-        for (const auto& [u, v] : E[h].out) {
-          H[id].push(v);
+      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) {
+        if (RT[C[w]].adjList[h].contains(a)) {
+          H[C[w]].push(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]].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 });
     }
   }
 }

include/algorithm/italiano.h

@@ -3,7 +3,6 @@
 
 #include "algorithm/decremental_reachability.h"
 #include "graph/breadth_first_tree.h"
-
 #include <stack>
 
 namespace algo {
@@ -25,7 +24,7 @@ public:
   // Delete collection of edges
   void remove(const std::vector<std::pair<T, T>>& edges) override;
 
-  // Delete edge e(u, v) and explicitely maintain the transitive closure
+  // Delete edge e(u, v) and explicitly maintain the transitive closure
   void remove(const T& u, const T& v);
 private:
   // Transitive closure matrix
@@ -41,8 +40,11 @@ private:
   };
   std::unordered_map<T, Edges> E;
 
+  //
+  std::unordered_map<T, std::stack<T>> H;
+
   // Repair reachability trees after edge deletions
-  void repairTrees(std::unordered_map<T, std::stack<T>>& H);
+  void repairTrees();
 };
 
 template<typename T>
@@ -67,53 +69,54 @@ bool Italiano<T>::query(const T& u, const T& v) {
 
 template<typename T>
 void Italiano<T>::remove(const std::vector<std::pair<T, T>>& edges) {
-  for (const auto& [u, v] : 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) {
-  if (!this->G.adjList[u].contains(v)) return;
-
-  std::unordered_map<T, std::stack<T>> H;
-  for (const auto& w : this->G.vertices()) {
-    if (RT[w].contains(u, v)) {
-      if (E[v].inc.size() > 1)
-        H[w].push(v);
-      else {
-        TC[w][v] = false;
-        for (const auto& c : E[v].out)
-          H[w].push(c);
-      }
-      RT[w].adjList[u].erase(v);
-    }
-  }
+  this->G.remove(u, v);
   E[u].out.erase(v);
   E[v].inc.erase(u);
-  this->G.remove(u, v);
+  
+  for (const auto& w : this->G.vertices()) {
+    if (!RT[w].adjList[u].contains(v)) continue;
 
-  repairTrees(H);
+    RT[w].adjList[u].erase(v);
+    if (E[v].inc.size() > 0) {
+      H[w].push(v);
+      continue;
+    }
+    TC[w][v] = false;
+    for (const auto& c : E[v].out)
+      H[w].push(c);
+  }
+  repairTrees();
 }
 
 template<typename T>
-void Italiano<T>::repairTrees(std::unordered_map<T, std::stack<T>>& H) {
-  for (const auto& z : this->G.vertices()) {
-    while (H[z].size() > 0) {
-      const auto& h = H[z].top();
-      bool found = false;
+void Italiano<T>::repairTrees() {
+  for (const auto& w : this->G.vertices()) {
+    while (H[w].size() > 0) {
+      const auto& h = H[w].top();
+      H[w].pop();
+      bool foundHook = false;
 
       for (const auto& i : E[h].inc) {
-        if (RT[z].contains(z, i)) {
-          RT[z].adjList[i].insert(h);
-          found = true;
+        if (RT[w].adjList[w].contains(i)) {
+          RT[w].adjList[i].insert(h);
+          foundHook = true;
           break;
         }
       }
-      H[z].pop();
-      if (!found) {
-        TC[z][h] = false;
-        for (const auto& o : E[h].out) {
-          H[z].push(o);
+      if (foundHook) continue;
+
+      TC[w][h] = false;
+      for (const auto& o : E[h].out) {
+        if (RT[w].adjList[h].contains(o)) {
+          H[w].push(o);
         }
       }
     }

include/algorithm/roditty_zwick.h

@@ -29,7 +29,7 @@ public:
   // Remove edge (u,v) and update A accordingly for fast checking query
   void remove(const T& u, const T& v);
 
-  std::unordered_map<T, SCC<T>> getSCCs() { return C; }
+  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;
@@ -51,16 +51,16 @@ template<typename T>
 void RodittyZwick<T>::findSCC(graph::Digraph<T> G) {
   auto SCCs = Tarjan<T>(G.adjList).execute();
   
-  for (auto& SCC : SCCs) {
-    const auto& w = SCC.id;
+  for (auto& c : SCCs) {
+    const auto& w = c.id;
 
-    for (const auto& v : SCC.vertices())
+    for (const auto& v : c.vertices())
       A[v] = w;
     
-    Out[w] = BreadthFirstTree<T>(SCC, w);
-    In[w] = BreadthFirstTree<T>(SCC.reverse(), w);
+    Out[w] = BreadthFirstTree<T>(c, w);
+    In[w] = BreadthFirstTree<T>(c.reverse(), w);
 
-    C[w] = SCC;
+    C[w] = c;
   }
 }
 
@@ -82,19 +82,20 @@ void RodittyZwick<T>::remove(const T& u, const T& v) {
   this->G.remove(u, v);
 
   // If u and v are not in the same SCC, do nothing
-  if (A[u] != A[v]) return;
+  if (A[u] != A[v])
+    return;
 
-  // If edge (u,v) is not contained in both inTree and outTree do nothing
-  if (!In[w].adjList[u].contains(v) &&
-      !Out[w].adjList[u].contains(v))
+  // 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;
 
   // Update In(w) and Out(w)
   Out[w] = BreadthFirstTree<T>(C[w], w);
   In[w] = BreadthFirstTree<T>(C[w].reverse(), w);
 
-  // If a SCC is broken, compute all SCCs again
-  if (!In[w].adjList.count(u) || !Out[w].adjList.count(v))
+  // If a SCC is broken, compute the new SCCs
+  if (!In[w].contains(u) || !Out[w].contains(v))
     findSCC(C[w]);
 }
 

include/algorithm/tarjan.h

@@ -18,7 +18,7 @@ public:
 
   //
   auto execute();
-
+  
   //
   void strongConnect(const T& u);
 private:
@@ -26,33 +26,33 @@ private:
   std::stack<T> S;
   std::int16_t index = 0;
   std::vector<graph::SCC<T>> SCCs;
-  T cid;
+  T cid{};
 
   struct Vertex {
     int index = -1;
     int lowlink = -1;
     bool onStack = false;
   };
-  std::unordered_map<T, Vertex> vmap;
+  std::unordered_map<T, Vertex> V;
 };
 
 template<typename T>
 void Tarjan<T>::strongConnect(const T& u) {
-  vmap[u].index = vmap[u].lowlink = index++;
+  V[u].index = V[u].lowlink = index++;
   S.push(u);
-  vmap[u].onStack = true;
+  V[u].onStack = true;
 
   for (const auto& w : adjList[u]) {
-    if (vmap[w].index == -1) {
+    if (V[w].index == -1) {
       strongConnect(w);
-      vmap[u].lowlink = std::min(vmap[u].lowlink, vmap[w].lowlink);
-    } else if (vmap[w].onStack) {
-      vmap[u].lowlink = std::min(vmap[u].lowlink, vmap[w].index);
+      V[u].lowlink = std::min(V[u].lowlink, V[w].lowlink);
+    } else if (V[w].onStack) {
+      V[u].lowlink = std::min(V[u].lowlink, V[w].index);
     }
   }
 
   // If u is a root node, pop the stack and generate an SCC
-  if (vmap[u].lowlink == vmap[u].index) {
+  if (V[u].lowlink == V[u].index) {
     std::unordered_map<T, std::unordered_set<T>> scc;
     bool finished = false;
     cid = S.top();
@@ -60,7 +60,7 @@ void Tarjan<T>::strongConnect(const T& u) {
     do {
       const auto w = S.top();
       S.pop();
-      vmap[w].onStack = false;
+      V[w].onStack = false;
       scc[w] = adjList[w];
       finished = (w == u);
     } while (!finished);
@@ -72,7 +72,7 @@ void Tarjan<T>::strongConnect(const T& u) {
 template<typename T>
 auto Tarjan<T>::execute() {
   for (const auto& u : std::views::keys(adjList)) {
-    if (vmap[u].index == -1)
+    if (V[u].index == -1)
       strongConnect(u);
   }
   return SCCs;