Add default param constructors, create bool query for bfs and tests

algorithm/tarjan.h

@@ -5,6 +5,7 @@
 
 #include <stack>
 #include <vector>
+#include <ranges>
 
 using namespace graph;
 
@@ -13,68 +14,75 @@ namespace algo {
 template<typename T>
 class Tarjan {
 public:
-  Tarjan(Digraph<T> G) : G(G) {}
+  Tarjan() = default;
 
-  std::vector<SCC<T>> execute();
+  Tarjan(std::map<T, std::set<T>> adjMatrix) : adjMatrix(adjMatrix) {}
 
-  void strongConnect(const T& v);
+  auto execute();
+
+  void strongConnect(const T& u);
+
+  void setGraph(std::map<T, std::set<T>> adjMatrix);
 private:
-  // Necessary info about vertices when running Tarjan's algorithm
-  struct Payload {
-    std::int16_t index = -1;
-    std::int16_t lowlink = -1;
-    bool onStack = false;
-  };
-
-  Digraph<T> G;
+  std::map<T, std::set<T>> adjMatrix;
   std::stack<T> S;
   std::int16_t index = 0;
-  std::map<T, Payload> p;
   std::vector<SCC<T>> SCCs;
+
+  struct Vertex {
+    int index = -1;
+    int lowlink = -1;
+    bool onStack = false;
+  };
+  std::map<T, Vertex> vmap;
 };
 
 template<typename T>
-void Tarjan<T>::strongConnect(const T& v) {
-  p[v].index = p[v].lowlink = index++;
-  p[v].onStack = true;
-  S.push(v);
-  
-  for (const auto& w : G.adjMatrix[v]) {
-    if (p[w].index == -1) {
+void Tarjan<T>::strongConnect(const T& u) {
+  vmap[u].index = vmap[u].lowlink = index++;
+  S.push(u);
+  vmap[u].onStack = true;
+
+  for (const auto& w : adjMatrix[u]) {
+    if (vmap[w].index == -1) {
       strongConnect(w);
-      p[v].lowlink = std::min(p[v].lowlink, p[w].lowlink);
-    } else if (p[w].onStack) {
-      p[v].lowlink = std::min(p[v].lowlink, p[w].index);
+      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);
     }
   }
 
-  // If v is a root node, pop the stack and generate an SCC
-  if (p[v].lowlink == p[v].index) {
-    //std::vector<T> scc;
+  // If u is a root node, pop the stack and generate an SCC
+  if (vmap[u].lowlink == vmap[u].index) {
     std::map<T, std::set<T>> scc;
     bool finished = false;
+
     do {
       const auto w = S.top();
       S.pop();
-      p[w].onStack = false;
-      scc[w] = G.adjMatrix[w];
-      finished = p[w].index == p[v].index;
+      vmap[w].onStack = false;
+      scc[w] = adjMatrix[w];
+      finished = (w == u);
     } while (!finished);
-    SCCs.push_back(scc);
+    
+    SCCs.push_back({ scc, static_cast<T>(vmap[u].lowlink) });
   }
 }
 
 template<typename T>
-std::vector<SCC<T>> Tarjan<T>::execute() {
-  for (auto& v : G.adjMatrix) {
-    if (p[v.first].index == -1) {
-      strongConnect(v.first);
-    }
+auto Tarjan<T>::execute() {
+  for (const auto& u : std::views::keys(adjMatrix)) {
+    if (vmap[u].index == -1)
+      strongConnect(u);
   }
-
   return SCCs;
 }
 
+template<typename T>
+void Tarjan<T>::setGraph(std::map<T, std::set<T>> adjMatrix) {
+  this->adjMatrix = adjMatrix;
+}
+
 } // namespace algo
 
 #endif