stefiosif/reachability-algorithms
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use clang-format

Browse Source
This commit is contained in:
stefiosif
2024-08-03 13:14:42 +03:00
parent d216a9611f
commit 3951db7ff9
17 changed files with 262 additions and 287 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
benchmark/algorithm_bench.cc
View File

@@ -1,3 +1,4 @@
#include <src/include/nanobench.h> #include <src/include/nanobench.h>
#include <doctest/doctest.h> #include <doctest/doctest.h>
@@ -8,6 +9,7 @@
#include <random> #include <random>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <memory>
using namespace graph; using namespace graph;

32
include/algorithm/breadth_first_search.h
View File

@@ -1,35 +1,38 @@
#ifndef BREADTH_FIRST_SEARCH_H_ #ifndef BREADTH_FIRST_SEARCH_H_
#define BREADTH_FIRST_SEARCH_H_ #define BREADTH_FIRST_SEARCH_H_
#include "graph/graph.h"
#include <map> #include <map>
#include <set>
#include <queue> #include <queue>
#include <set>
using namespace graph; using namespace graph;
namespace algo { namespace algo {
template<typename T> template <typename T> class BreadthFirstSearch {
class BreadthFirstSearch {
public: public:
BreadthFirstSearch() = default; BreadthFirstSearch() = default;
explicit BreadthFirstSearch(std::unordered_map<T, std::unordered_set<T>> adjList) explicit BreadthFirstSearch(
: adjList(adjList) {} std::unordered_map<T, std::unordered_set<T>> adjList)
: adjList(adjList) {}
// Traverse whole graph using the BFS search, and save the tree graph // Traverse whole graph using the BFS search, and save the tree graph
// which is created when visiting new vertices (Breadth First Tree) // 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 // Search if target vertex exists in graph
bool query(const T& root, const T& target); bool query(const T &root, const T &target);
private: private:
// Represents the graph on which the algorithm will be executed // Represents the graph on which the algorithm will be executed
std::unordered_map<T, std::unordered_set<T>> adjList; std::unordered_map<T, std::unordered_set<T>> adjList;
}; };
template<typename T> 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>>
BreadthFirstSearch<T>::execute(const T &root) {
std::unordered_map<T, std::unordered_set<T>> tree; std::unordered_map<T, std::unordered_set<T>> tree;
std::unordered_map<T, bool> visited; std::unordered_map<T, bool> visited;
std::queue<T> Q; 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(); const auto v = Q.front();
Q.pop(); Q.pop();
for (const auto& u : adjList[v]) { for (const auto &u : adjList[v]) {
if (!visited[u]) { if (!visited[u]) {
visited[u] = true; visited[u] = true;
tree[v].insert(u); tree[v].insert(u);
@@ -52,8 +55,8 @@ std::unordered_map<T, std::unordered_set<T>> BreadthFirstSearch<T>::execute(cons
return tree; return tree;
} }
template<typename T> template <typename T>
bool BreadthFirstSearch<T>::query(const T& root, const T& target) { bool BreadthFirstSearch<T>::query(const T &root, const T &target) {
std::unordered_map<T, bool> visited; std::unordered_map<T, bool> visited;
std::queue<T> Q; std::queue<T> Q;
Q.push(root); Q.push(root);
@@ -63,9 +66,10 @@ bool BreadthFirstSearch<T>::query(const T& root, const T& target) {
const auto v = Q.front(); const auto v = Q.front();
Q.pop(); 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]) { if (!visited[u]) {
visited[u] = true; visited[u] = true;
Q.push(u); Q.push(u);

11
include/algorithm/decremental_reachability.h
View File

@@ -4,21 +4,20 @@
#include "graph/digraph.h" #include "graph/digraph.h"
namespace algo { namespace algo {
template <typename T> class DecrementalReachability {
template<typename T>
class DecrementalReachability {
public: public:
virtual ~DecrementalReachability() = default; virtual ~DecrementalReachability() = default;
// This method is implemented and executed by all roditty and zwick // This method is implemented and executed by all roditty and zwick
// algorithms, it constructs the data structures used in other operations // 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 // 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 // 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: protected:
Digraph<T> G; Digraph<T> G;
}; };

6
include/algorithm/dynamic_reachability.h
View File

@@ -4,15 +4,13 @@
#include "algorithm/decremental_reachability.h" #include "algorithm/decremental_reachability.h"
namespace algo { namespace algo {
template <typename T>
template<typename T>
class DynamicReachability : public DecrementalReachability<T> { class DynamicReachability : public DecrementalReachability<T> {
// Insert edge e(u,v) and maintain the transitive closure matrix // 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 } // namespace algo
#endif #endif

141
include/algorithm/frigioni.h
View File

@@ -8,8 +8,7 @@
namespace algo { namespace algo {
template<typename T> template <typename T> class Frigioni : public DecrementalReachability<T> {
class Frigioni : public DecrementalReachability<T> {
public: public:
Frigioni() = default; Frigioni() = default;
@@ -20,10 +19,11 @@ public:
// Execute reachability query q(u, v) from vertex u to vertex v // Execute reachability query q(u, v) from vertex u to vertex v
// in O(1) using the transitive closure matrix // 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 // 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: private:
// Transitive closure matrix, used to answer reachability queries in O(1) // Transitive closure matrix, used to answer reachability queries in O(1)
std::unordered_map<T, std::unordered_map<T, bool>> TC; std::unordered_map<T, std::unordered_map<T, bool>> TC;
@@ -46,161 +46,162 @@ private:
RodittyZwick<T> rodittyZwick; RodittyZwick<T> rodittyZwick;
// Delete internal edge e(u, v) // 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) // 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 // Repair reachability trees
void repairTrees(); 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> template <typename T> void Frigioni<T>::init() {
void Frigioni<T>::init() {
rodittyZwick = RodittyZwick<T>(this->G); rodittyZwick = RodittyZwick<T>(this->G);
rodittyZwick.init(); rodittyZwick.init();
auto C = rodittyZwick.getComponentMap(); 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); RT[C[w]] = BreadthFirstTree<T>(this->G, w);
for (const auto& u : this->G.vertices()) { for (const auto &u : this->G.vertices()) {
for (const auto& v : this->G.adjList[u]) { for (const auto &v : this->G.adjList[u]) {
if (!C[w].contains(u) && C[w].contains(v)) 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)) 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 else
E[C[w]].in.insert({ u, v }); E[C[w]].in.insert({u, v});
TC[u][v] = false; TC[u][v] = false;
} }
} }
} }
for (const auto& w : std::views::keys(C)) { for (const auto &w : std::views::keys(C)) {
for (const auto& u : C[w].vertices()) { for (const auto &u : C[w].vertices()) {
for (const auto& v : RT[C[w]].vertices()) { for (const auto &v : RT[C[w]].vertices()) {
TC[u][v] = true; TC[u][v] = true;
} }
} }
} }
} }
template<typename T> template <typename T> bool Frigioni<T>::query(const T &u, const T &v) {
bool Frigioni<T>::query(const T& u, const T& v) {
return TC[u][v]; return TC[u][v];
} }
template<typename T> template <typename T>
void Frigioni<T>::remove(const std::vector<std::pair<T, T>>& edges) { 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>> Eint;
std::vector<std::pair<T, T>> Eext; std::vector<std::pair<T, T>> Eext;
for (const auto& [u, v] : edges) { for (const auto &[u, v] : edges) {
if (!this->G.adjList[u].contains(v)) continue; if (!this->G.adjList[u].contains(v))
continue;
if (rodittyZwick.query(u, v)) if (rodittyZwick.query(u, v))
Eint.push_back({ u, v }); Eint.push_back({u, v});
else 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] : Eint)
for (const auto& [u, v] : Eext) removeExternal(u, v); removeInternal(u, v);
for (const auto &[u, v] : Eext)
removeExternal(u, v);
repairTrees(); repairTrees();
} }
template<typename T> template <typename T> void Frigioni<T>::removeInternal(const T &u, const T &v) {
void Frigioni<T>::removeInternal(const T& u, const T& v) {
this->G.remove(u, v); this->G.remove(u, v);
auto L = rodittyZwick.getComponentMap(); auto L = rodittyZwick.getComponentMap();
rodittyZwick.remove(u, v); rodittyZwick.remove(u, v);
auto C = rodittyZwick.getComponentMap(); auto C = rodittyZwick.getComponentMap();
if (rodittyZwick.query(u, v)) { if (rodittyZwick.query(u, v)) {
E[C[u]].in.erase({ u, v }); E[C[u]].in.erase({u, v});
return; return;
} }
if (L[u] == C[u]) { if (L[u] == C[u]) {
E[L[u]].out.erase({ u, v }); E[L[u]].out.erase({u, v});
E.erase(L[v]); E.erase(L[v]);
splitEdges(L, C, v); splitEdges(L, C, v);
} } else {
else { E[L[v]].inc.erase({u, v});
E[L[v]].inc.erase({ u, v });
E.erase(L[u]); E.erase(L[u]);
splitEdges(L, C, u); splitEdges(L, C, u);
} }
for (const auto& w : std::views::keys(C)) { for (const auto &w : std::views::keys(C)) {
if (!RT[C[w]].contains(v)) continue; if (!RT[C[w]].contains(v))
continue;
RT[C[w]].removeEdgeTo(v); RT[C[w]].removeEdgeTo(v);
if (E[C[v]].inc.size() > 0) { if (E[C[v]].inc.size() > 0) {
H[C[w]].push(v); /*h mipos C[v].id?*/ H[C[w]].push(v); /*h mipos C[v].id?*/
continue; continue;
} }
for (const auto& x : C[w].vertices()) { for (const auto &x : C[w].vertices()) {
for (const auto& y : C[v].vertices()) { for (const auto &y : C[v].vertices()) {
TC[x][y] = false; 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); H[C[w]].push(b);
} }
} }
template<typename T> template <typename T> void Frigioni<T>::removeExternal(const T &u, const T &v) {
void Frigioni<T>::removeExternal(const T& u, const T& v) {
this->G.remove(u, v); this->G.remove(u, v);
auto C = rodittyZwick.getComponentMap(); auto C = rodittyZwick.getComponentMap();
E[C[v]].inc.erase({ u, v }); E[C[v]].inc.erase({u, v});
E[C[u]].out.erase({ u, v }); E[C[u]].out.erase({u, v});
for (const auto& w : std::views::keys(C)) { for (const auto &w : std::views::keys(C)) {
if (!RT[C[w]].contains(v)) continue; if (!RT[C[w]].contains(v))
continue;
RT[C[w]].removeEdgeTo(v); RT[C[w]].removeEdgeTo(v);
if (E[C[v]].inc.size() > 0) { if (E[C[v]].inc.size() > 0) {
H[C[w]].push(v); H[C[w]].push(v);
continue; continue;
} }
for (const auto& x : C[w].vertices()) { for (const auto &x : C[w].vertices()) {
for (const auto& y : C[v].vertices()) { for (const auto &y : C[v].vertices()) {
TC[x][y] = false; 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); H[C[w]].push(b);
} }
} }
template<typename T> template <typename T> void Frigioni<T>::repairTrees() {
void Frigioni<T>::repairTrees() {
auto C = rodittyZwick.getComponentMap(); 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) { while (H[C[w]].size() > 0) {
const auto& h = H[C[w]].top(); const auto &h = H[C[w]].top();
H[C[w]].pop(); H[C[w]].pop();
bool foundHook = false; 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)) { if (RT[C[w]].adjList[w].contains(a)) {
RT[C[w]].insert(a, h); RT[C[w]].insert(a, h);
foundHook = true; foundHook = true;
break; break;
} }
} }
if (foundHook) continue; if (foundHook)
continue;
for (const auto& x : C[w].vertices()) { for (const auto &x : C[w].vertices()) {
for (const auto& y : C[h].vertices()) { for (const auto &y : C[h].vertices()) {
TC[x][y] = false; 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)) { if (RT[C[w]].adjList[h].contains(a)) {
H[C[w]].push(b); H[C[w]].push(b);
} }
@@ -209,21 +210,21 @@ void Frigioni<T>::repairTrees() {
} }
} }
template<typename T> template <typename T>
void Frigioni<T>::splitEdges(std::unordered_map<T, SCC<T>>& L, std::unordered_map<T, SCC<T>> C, const T& w) { void Frigioni<T>::splitEdges(std::unordered_map<T, SCC<T>> &L,
for (const auto& [a, b] : E[L[w]].inc) std::unordered_map<T, SCC<T>> C, const T &w) {
E[C[b]].inc.insert({ a, b }); 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) for (const auto &[a, b] : E[L[w]].out)
E[C[a]].out.insert({ a, b }); 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]) { if (C[a] == C[b]) {
E[C[a]].in.insert({ a, b }); E[C[a]].in.insert({a, b});
} } else {
else { E[C[a]].out.insert({a, b});
E[C[a]].out.insert({ a, b }); E[C[b]].in.insert({a, b});
E[C[b]].in.insert({ a, b });
} }
} }
} }

38
include/algorithm/henzinger_king.h
View File

@@ -8,8 +8,7 @@ constexpr int threshold = 5;
namespace algo { namespace algo {
template<typename T> template <typename T> class HenzingerKing : public DynamicReachability<T> {
class HenzingerKing : public DynamicReachability<T> {
public: public:
HenzingerKing() = default; HenzingerKing() = default;
@@ -21,16 +20,17 @@ public:
// Execute query q(u, v) from vertex u to vertex v by querying the // Execute query q(u, v) from vertex u to vertex v by querying the
// decremental reachability data structure at the start of the phase // decremental reachability data structure at the start of the phase
// and then if necessary check the set S // 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 // Remove collection of edges from the decremental maintenance data structure
// and for every vertex in set S, rebuilt reachability trees from scratch // 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 // Insert collection of edges in set S, if threshold is reached re-initialize
// algorithm, otherwise construct reachability trees for the vertex that is // algorithm, otherwise construct reachability trees for the vertex that is
// the center-of-insertions // 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: private:
// Decremental maintenance data structure // Decremental maintenance data structure
Frigioni<T> frigioni; Frigioni<T> frigioni;
@@ -43,41 +43,37 @@ private:
std::unordered_map<T, BreadthFirstTree<T>> Out; std::unordered_map<T, BreadthFirstTree<T>> Out;
}; };
template<typename T> template <typename T> void HenzingerKing<T>::init() {
void HenzingerKing<T>::init() {
S.clear(); S.clear();
frigioni = Frigioni<T>(this->G); frigioni = Frigioni<T>(this->G);
frigioni.init(); frigioni.init();
} }
template<typename T> template <typename T> bool HenzingerKing<T>::query(const T &u, const T &v) {
bool HenzingerKing<T>::query(const T& u, const T& v) {
if (frigioni.query(u, v)) if (frigioni.query(u, v))
return true; return true;
return std::ranges::any_of(S.begin(), S.end(), return std::ranges::any_of(S.begin(), S.end(), [&](const T &w) {
[&](const T& w) { return In[w].adjList.contains(u) && Out[w].adjList.contains(v);
return In[w].adjList.contains(u) && });
Out[w].adjList.contains(v);
});
} }
template<typename T> template <typename T>
void HenzingerKing<T>::remove(const std::vector<std::pair<T, T>>& edges) { void HenzingerKing<T>::remove(const std::vector<std::pair<T, T>> &edges) {
for (const auto& [u, v] : edges) { for (const auto &[u, v] : edges) {
this->G.remove(u, v); this->G.remove(u, v);
} }
frigioni.remove(edges); frigioni.remove(edges);
for (const auto& w : S) { for (const auto &w : S) {
In[w] = BreadthFirstTree(this->G.reverse(), w); In[w] = BreadthFirstTree(this->G.reverse(), w);
Out[w] = BreadthFirstTree(this->G, w); Out[w] = BreadthFirstTree(this->G, w);
} }
} }
template<typename T> template <typename T>
void HenzingerKing<T>::insert(const T& c, const std::vector<T>& vertices) { void HenzingerKing<T>::insert(const T &c, const std::vector<T> &vertices) {
for (const auto& w : vertices) for (const auto &w : vertices)
this->G.insert(c, w); this->G.insert(c, w);
S.insert(c); S.insert(c);

55
include/algorithm/italiano.h
View File

@@ -7,8 +7,7 @@
namespace algo { namespace algo {
template<typename T> template <typename T> class Italiano : public DecrementalReachability<T> {
class Italiano : public DecrementalReachability<T> {
public: public:
Italiano() = default; Italiano() = default;
@@ -19,13 +18,14 @@ public:
// Execute reachability query q(u, v) from vertex u to vertex v // Execute reachability query q(u, v) from vertex u to vertex v
// in O(1) using the transitive closure matrix // 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 // 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 // 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: private:
// Transitive closure matrix // Transitive closure matrix
std::unordered_map<T, std::unordered_map<T, bool>> TC; std::unordered_map<T, std::unordered_map<T, bool>> TC;
@@ -47,42 +47,41 @@ private:
void repairTrees(); void repairTrees();
}; };
template<typename T> template <typename T> void Italiano<T>::init() {
void Italiano<T>::init() { for (const auto &u : this->G.vertices()) {
for (const auto& u : this->G.vertices()) { for (const auto &v : this->G.adjList[u]) {
for (const auto& v : this->G.adjList[u]) {
E[v].inc.insert(u); E[v].inc.insert(u);
E[u].out.insert(v); E[u].out.insert(v);
TC[u][v] = false; TC[u][v] = false;
} }
RT[u] = BreadthFirstTree<T>(this->G, u); RT[u] = BreadthFirstTree<T>(this->G, u);
TC[u][u] = true; TC[u][u] = true;
for (const auto& v : RT[u].vertices()) for (const auto &v : RT[u].vertices())
TC[u][v] = true; TC[u][v] = true;
} }
} }
template<typename T> template <typename T> bool Italiano<T>::query(const T &u, const T &v) {
bool Italiano<T>::query(const T& u, const T& v) {
return TC[u][v]; return TC[u][v];
} }
template<typename T> template <typename T>
void Italiano<T>::remove(const std::vector<std::pair<T, T>>& edges) { 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; if (!this->G.adjList[u].contains(v))
continue;
remove(u, v); remove(u, v);
} }
} }
template<typename T> template <typename T> void Italiano<T>::remove(const T &u, const T &v) {
void Italiano<T>::remove(const T& u, const T& v) {
this->G.remove(u, v); this->G.remove(u, v);
E[u].out.erase(v); E[u].out.erase(v);
E[v].inc.erase(u); E[v].inc.erase(u);
for (const auto& w : this->G.vertices()) { for (const auto &w : this->G.vertices()) {
if (!RT[w].adjList[u].contains(v)) continue; if (!RT[w].adjList[u].contains(v))
continue;
RT[w].adjList[u].erase(v); RT[w].adjList[u].erase(v);
if (E[v].inc.size() > 0) { if (E[v].inc.size() > 0) {
@@ -90,31 +89,31 @@ void Italiano<T>::remove(const T& u, const T& v) {
continue; continue;
} }
TC[w][v] = false; TC[w][v] = false;
for (const auto& c : E[v].out) for (const auto &c : E[v].out)
H[w].push(c); H[w].push(c);
} }
repairTrees(); repairTrees();
} }
template<typename T> template <typename T> void Italiano<T>::repairTrees() {
void Italiano<T>::repairTrees() { for (const auto &w : this->G.vertices()) {
for (const auto& w : this->G.vertices()) {
while (H[w].size() > 0) { while (H[w].size() > 0) {
const auto& h = H[w].top(); const auto &h = H[w].top();
H[w].pop(); H[w].pop();
bool foundHook = false; bool foundHook = false;
for (const auto& i : E[h].inc) { for (const auto &i : E[h].inc) {
if (RT[w].adjList[w].contains(i)) { if (RT[w].adjList[w].contains(i)) {
RT[w].adjList[i].insert(h); RT[w].adjList[i].insert(h);
foundHook = true; foundHook = true;
break; break;
} }
} }
if (foundHook) continue; if (foundHook)
continue;
TC[w][h] = false; 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)) { if (RT[w].adjList[h].contains(o)) {
H[w].push(o); H[w].push(o);
} }

44
include/algorithm/king.h
View File

@@ -6,8 +6,7 @@
namespace algo { namespace algo {
template<typename T> template <typename T> class King : public DynamicReachability<T> {
class King : public DynamicReachability<T> {
public: public:
King() = default; King() = default;
@@ -19,26 +18,26 @@ public:
// Execute reachability query q(u, v) from vertex u to vertex v // Execute reachability query q(u, v) from vertex u to vertex v
// in O(n) using the stored decremental maintenance data structure for DAGs // 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 // 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 // Delete edge e(u, v) from all reachability trees and update each one of
// them using the decremental reachability algorithm for DAGs // 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 // 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: private:
// Connect each reachabiliy tree with decremental maintenance data structure // Connect each reachabiliy tree with decremental maintenance data structure
std::unordered_map<T, Italiano<T>> In; std::unordered_map<T, Italiano<T>> In;
std::unordered_map<T, Italiano<T>> Out; std::unordered_map<T, Italiano<T>> Out;
}; };
template<typename T> template <typename T> void King<T>::init() {
void King<T>::init() { for (const auto &u : this->G.vertices()) {
for (const auto& u : this->G.vertices()) {
In[u] = Italiano<T>(BreadthFirstTree<T>(this->G.reverse(), u)); In[u] = Italiano<T>(BreadthFirstTree<T>(this->G.reverse(), u));
In[u].init(); In[u].init();
Out[u] = Italiano<T>(BreadthFirstTree<T>(this->G, u)); Out[u] = Italiano<T>(BreadthFirstTree<T>(this->G, u));
@@ -46,32 +45,29 @@ void King<T>::init() {
} }
} }
template<typename T> template <typename T> bool King<T>::query(const T &u, const T &v) {
bool King<T>::query(const T& u, const T& v) { return std::any_of(
return std::ranges::any_of(this->G.vertices().begin(), this->G.vertices().end(), this->G.vertices().begin(), this->G.vertices().end(),
[&](const T& w) { [&](const T &w) { return In[w].query(w, u) && Out[w].query(w, v); });
return In[w].query(w, u) && Out[w].query(w, v);
});
} }
template<typename T> template <typename T>
void King<T>::remove(const std::vector<std::pair<T, T>>& edges) { void King<T>::remove(const std::vector<std::pair<T, T>> &edges) {
for (const auto& [u, v] : edges) for (const auto &[u, v] : edges)
remove(u, v); remove(u, v);
} }
template<typename T> template <typename T> void King<T>::remove(const T &u, const T &v) {
void King<T>::remove(const T& u, const T& v) {
this->G.remove(u, 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); In[w].remove(v, u);
Out[w].remove(u, v); Out[w].remove(u, v);
} }
} }
template<typename T> template <typename T>
void King<T>::insert(const T& c, const std::vector<T>& vertices) { void King<T>::insert(const T &c, const std::vector<T> &vertices) {
for (const auto& v : vertices) { for (const auto &v : vertices) {
this->G.insert(c, v); this->G.insert(c, v);
} }
In[c] = Italiano<T>(BreadthFirstTree<T>(this->G.reverse(), c)); In[c] = Italiano<T>(BreadthFirstTree<T>(this->G.reverse(), c));

43
include/algorithm/roditty_zwick.h
View File

@@ -7,8 +7,7 @@
namespace algo { namespace algo {
template<typename T> template <typename T> class RodittyZwick : public DecrementalReachability<T> {
class RodittyZwick : public DecrementalReachability<T> {
public: public:
RodittyZwick() = default; RodittyZwick() = default;
@@ -21,15 +20,16 @@ public:
void findSCC(graph::Digraph<T> G); void findSCC(graph::Digraph<T> G);
// Return true if u and v are in the same SCC // 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 // 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 // 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; } std::unordered_map<T, SCC<T>> getComponentMap() { return C; }
private: private:
// Array used to answer strong connectivity queries in O(1) time // Array used to answer strong connectivity queries in O(1) time
std::unordered_map<T, T> A; std::unordered_map<T, T> A;
@@ -42,19 +42,15 @@ private:
std::unordered_map<T, BreadthFirstTree<T>> Out; std::unordered_map<T, BreadthFirstTree<T>> Out;
}; };
template<typename T> template <typename T> void RodittyZwick<T>::init() { findSCC(this->G); }
void RodittyZwick<T>::init() {
findSCC(this->G);
}
template<typename T> template <typename T> void RodittyZwick<T>::findSCC(graph::Digraph<T> G) {
void RodittyZwick<T>::findSCC(graph::Digraph<T> G) {
auto SCCs = Tarjan<T>(G.adjList).execute(); auto SCCs = Tarjan<T>(G.adjList).execute();
for (auto& c : SCCs) { for (auto &c : SCCs) {
const auto& w = c.id; const auto &w = c.id;
for (const auto& v : c.vertices()) for (const auto &v : c.vertices())
A[v] = w; A[v] = w;
Out[w] = BreadthFirstTree<T>(c, w); Out[w] = BreadthFirstTree<T>(c, w);
@@ -64,20 +60,18 @@ void RodittyZwick<T>::findSCC(graph::Digraph<T> G) {
} }
} }
template<typename T> template <typename T> bool RodittyZwick<T>::query(const T &u, const T &v) {
bool RodittyZwick<T>::query(const T& u, const T& v) {
return A[u] == A[v]; return A[u] == A[v];
} }
template<typename T> template <typename T>
void RodittyZwick<T>::remove(const std::vector<std::pair<T, T>>& edges) { void RodittyZwick<T>::remove(const std::vector<std::pair<T, T>> &edges) {
for (const auto& [u, v] : edges) for (const auto &[u, v] : edges)
remove(u, v); remove(u, v);
} }
template<typename T> template <typename T> void RodittyZwick<T>::remove(const T &u, const T &v) {
void RodittyZwick<T>::remove(const T& u, const T& v) { const auto &w = A[u];
const auto& w = A[u];
C[w].remove(u, v); C[w].remove(u, v);
this->G.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]) if (A[u] != A[v])
return; return;
// If edge (u,v) is not contained in both inTree and outTree do nothing TODO:remove useless comments // If edge (u,v) is not contained in both inTree and outTree do nothing
// is this not better if i utilize A matrix, since we are going traversing between components.. ? TODO // 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)) if (!In[w].adjList[u].contains(v) && !Out[w].adjList[u].contains(v))
return; return;

23
include/algorithm/tarjan.h
View File

@@ -3,24 +3,25 @@
#include "graph/scc.h" #include "graph/scc.h"
#include <ranges>
#include <stack> #include <stack>
#include <vector> #include <vector>
#include <ranges>
namespace algo { namespace algo {
template<typename T> template <typename T> class Tarjan {
class Tarjan {
public: public:
Tarjan() = default; 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(); auto execute();
// //
void strongConnect(const T& u); void strongConnect(const T &u);
private: private:
std::unordered_map<T, std::unordered_set<T>> adjList; std::unordered_map<T, std::unordered_set<T>> adjList;
std::stack<T> S; std::stack<T> S;
@@ -36,13 +37,12 @@ private:
std::unordered_map<T, Vertex> V; std::unordered_map<T, Vertex> V;
}; };
template<typename T> template <typename T> void Tarjan<T>::strongConnect(const T &u) {
void Tarjan<T>::strongConnect(const T& u) {
V[u].index = V[u].lowlink = index++; V[u].index = V[u].lowlink = index++;
S.push(u); S.push(u);
V[u].onStack = true; V[u].onStack = true;
for (const auto& w : adjList[u]) { for (const auto &w : adjList[u]) {
if (V[w].index == -1) { if (V[w].index == -1) {
strongConnect(w); strongConnect(w);
V[u].lowlink = std::min(V[u].lowlink, V[w].lowlink); V[u].lowlink = std::min(V[u].lowlink, V[w].lowlink);
@@ -65,13 +65,12 @@ void Tarjan<T>::strongConnect(const T& u) {
finished = (w == u); finished = (w == u);
} while (!finished); } while (!finished);
SCCs.push_back({ scc, static_cast<T>(cid) }); SCCs.push_back({scc, static_cast<T>(cid)});
} }
} }
template<typename T> template <typename T> auto Tarjan<T>::execute() {
auto Tarjan<T>::execute() { for (const auto &u : std::views::keys(adjList)) {
for (const auto& u : std::views::keys(adjList)) {
if (V[u].index == -1) if (V[u].index == -1)
strongConnect(u); strongConnect(u);
} }

16
include/graph/breadth_first_tree.h
View File

@@ -5,30 +5,28 @@
namespace graph { namespace graph {
template<typename T> template <typename T> class BreadthFirstTree : public Digraph<T> {
class BreadthFirstTree : public Digraph<T> {
public: public:
BreadthFirstTree() = default; BreadthFirstTree() = default;
BreadthFirstTree(std::unordered_map<T, std::unordered_set<T>> G, T root) 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); BreadthFirstTree(Digraph<T> G, T root);
void removeEdgeTo(const T& u); void removeEdgeTo(const T &u);
T root{}; T root{};
}; };
template<typename T> template <typename T>
BreadthFirstTree<T>::BreadthFirstTree(Digraph<T> G, T root) { BreadthFirstTree<T>::BreadthFirstTree(Digraph<T> G, T root) {
this->adjList = algo::BreadthFirstSearch<T>(G.adjList).execute(root); this->adjList = algo::BreadthFirstSearch<T>(G.adjList).execute(root);
} }
template<typename T> template <typename T> void BreadthFirstTree<T>::removeEdgeTo(const T &u) {
void BreadthFirstTree<T>::removeEdgeTo(const T& u) { for (const auto &x : this->vertices()) {
for (const auto& x : this->vertices()) { for (const auto &y : this->adjList[x]) {
for (const auto& y : this->adjList[x]) {
if (y == u) { if (y == u) {
this->remove(x, u); this->remove(x, u);
return; return;

46
include/graph/digraph.h
View File

@@ -1,64 +1,59 @@
#ifndef DIGRAPH_H_ #ifndef DIGRAPH_H_
#define DIGRAPH_H_ #define DIGRAPH_H_
#include "graph.h"
#include "algorithm/breadth_first_search.h" #include "algorithm/breadth_first_search.h"
#include "graph.h"
namespace graph { namespace graph {
template<typename T> template <typename T> class Digraph : public Graph<T> {
class Digraph : public Graph<T> {
public: public:
Digraph() = default; Digraph() = default;
explicit Digraph(std::unordered_map<T, std::unordered_set<T>> G); explicit Digraph(std::unordered_map<T, std::unordered_set<T>> G);
// Return true if there is a path from u to v // 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) // 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) // Remove edge e(u,v)
void remove(const T& u, const T& v); void remove(const T &u, const T &v);
// Reverse graph directions // Reverse graph directions
auto reverse(); auto reverse();
// //
auto contains(const T& u); auto contains(const T &u);
friend std::ostream& operator<<<>(std::ostream& os, Digraph<T>& G);
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) { Digraph<T>::Digraph(std::unordered_map<T, std::unordered_set<T>> G) {
this->adjList = G; this->adjList = G;
} }
template<typename T> template <typename T> bool Digraph<T>::contains(const T &u, const T &v) {
bool Digraph<T>::contains(const T& u, const T& v) {
return algo::BreadthFirstSearch<T>(this->adjList).query(u, v); return algo::BreadthFirstSearch<T>(this->adjList).query(u, v);
} }
template<typename T> template <typename T> void Digraph<T>::insert(const T &u, const T &v) {
void Digraph<T>::insert(const T& u, const T& v) {
this->adjList[u].insert(v); this->adjList[u].insert(v);
this->adjList[v]; this->adjList[v];
} }
template<typename T> template <typename T> void Digraph<T>::remove(const T &u, const T &v) {
void Digraph<T>::remove(const T& u, const T& v) {
this->adjList[u].erase(v); this->adjList[u].erase(v);
} }
template<typename T> template <typename T> auto Digraph<T>::reverse() {
auto Digraph<T>::reverse() {
std::unordered_map<T, std::unordered_set<T>> revMatrix; std::unordered_map<T, std::unordered_set<T>> revMatrix;
for (const auto& u : this->vertices()) { for (const auto &u : this->vertices()) {
for (const auto& v : this->adjList[u]) { for (const auto &v : this->adjList[u]) {
revMatrix[v].insert(u); revMatrix[v].insert(u);
} }
} }
@@ -66,17 +61,16 @@ auto Digraph<T>::reverse() {
return revMatrix; return revMatrix;
} }
template<typename T> template <typename T> auto Digraph<T>::contains(const T &u) {
auto Digraph<T>::contains(const T& u) {
return this->adjList.count(u); return this->adjList.count(u);
} }
template<typename T> template <typename T>
std::ostream& operator<<(std::ostream& os, Digraph<T>& G) { std::ostream &operator<<(std::ostream &os, Digraph<T> &G) {
os << "V: " << G.V() << " E: " << G.E() << '\n'; 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()) { if (!G.adjList[u].empty()) {
for (const auto& v : G.adjList[u]) { for (const auto &v : G.adjList[u]) {
os << u << "->" << v << ' '; os << u << "->" << v << ' ';
} }
os << '\n'; os << '\n';

32
include/graph/graph.h
View File

@@ -1,30 +1,29 @@
#ifndef GRAPH_H_ #ifndef GRAPH_H_
#define GRAPH_H_ #define GRAPH_H_
#include <unordered_map>
#include <unordered_set>
#include <ostream> #include <ostream>
#include <ranges> #include <ranges>
#include <unordered_map>
#include <unordered_set>
namespace graph { namespace graph {
// Forward declerations // Forward declerations
template<typename T> class Graph; template <typename T> class Graph;
template<typename T> std::ostream& operator<<(std::ostream& os, Graph<T>& G); template <typename T> std::ostream &operator<<(std::ostream &os, Graph<T> &G);
template<typename T> template <typename T> class Graph {
class Graph {
public: public:
virtual ~Graph() = default; virtual ~Graph() = default;
// Return true if there is a path from u to v // 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) // 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) // 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 // Return graph vertices
auto vertices() const; auto vertices() const;
@@ -37,31 +36,24 @@ public:
// Adjacency matrix representation // Adjacency matrix representation
std::unordered_map<T, std::unordered_set<T>> adjList; std::unordered_map<T, std::unordered_set<T>> adjList;
}; };
template<typename T> template <typename T> auto Graph<T>::vertices() const {
auto Graph<T>::vertices() const{
return std::views::keys(adjList); return std::views::keys(adjList);
} }
template<typename T> template <typename T> std::uint16_t Graph<T>::V() {
std::uint16_t Graph<T>::V() {
return static_cast<std::uint16_t>(adjList.size()); return static_cast<std::uint16_t>(adjList.size());
} }
template<typename T> template <typename T> std::uint16_t Graph<T>::E() {
std::uint16_t Graph<T>::E() {
std::uint16_t edges = 0; std::uint16_t edges = 0;
for (const auto& u : vertices()) { for (const auto &u : vertices()) {
edges += static_cast<std::uint16_t>(adjList[u].size()); edges += static_cast<std::uint16_t>(adjList[u].size());
} }
return edges; return edges;
} }
} // namespace graph } // namespace graph
#endif #endif

30
include/graph/scc.h
View File

@@ -8,18 +8,19 @@
namespace graph { namespace graph {
template<typename T> template <typename T> class SCC : public Digraph<T> {
class SCC : public Digraph<T> {
public: public:
SCC() = default; SCC() = default;
SCC(std::unordered_map<T, std::unordered_set<T>> G, T id) 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(); } SCC(Digraph<T> G, T id) : id(id) { normalize(); }
// Return true if u is part of this SCC // 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 // Representative vertex of this SCC
T id{}; T id{};
@@ -27,16 +28,16 @@ public:
// //
std::unordered_map<T, std::unordered_set<T>> neighboorList; std::unordered_map<T, std::unordered_set<T>> neighboorList;
bool operator==(const SCC& o) const; bool operator==(const SCC &o) const;
private: private:
// Erase all edges that include vertices outside this SCC // Erase all edges that include vertices outside this SCC
void normalize(); void normalize();
}; };
template<typename T> template <typename T> void SCC<T>::normalize() {
void SCC<T>::normalize() { for (const auto &u : this->vertices()) {
for (const auto& u : this->vertices()) { for (const auto &v : this->adjList[u]) {
for (const auto& v : this->adjList[u]) {
if (!this->contains(v)) { if (!this->contains(v)) {
this->adjList[u].erase(v); this->adjList[u].erase(v);
this->adjList.erase(v); this->adjList.erase(v);
@@ -46,19 +47,16 @@ void SCC<T>::normalize() {
} }
} }
template<typename T> template <typename T> bool SCC<T>::contains(const T &u) const {
bool SCC<T>::contains(const T& u) const {
return this->adjList.count(u); return this->adjList.count(u);
} }
template<typename T> template <typename T> bool SCC<T>::operator==(const SCC &o) const {
bool SCC<T>::operator==(const SCC& o) const {
return id == o.id; return id == o.id;
} }
template<typename T> template <typename T> struct HashSCC {
struct HashSCC { std::size_t operator()(const SCC<T> &C) const {
std::size_t operator()(const SCC<T>& C) const {
return static_cast<std::size_t>(C.id); return static_cast<std::size_t>(C.id);
} }
}; };

4
include/roditty_zwick.h
View File

@@ -1,9 +1,9 @@
#ifndef RODITTY_ZWICK_H_ #ifndef RODITTY_ZWICK_H_
#define RODITTY_ZWICK_H_ #define RODITTY_ZWICK_H_
#include "algorithm/italiano.h"
#include "algorithm/frigioni.h" #include "algorithm/frigioni.h"
#include "algorithm/king.h"
#include "algorithm/henzinger_king.h" #include "algorithm/henzinger_king.h"
#include "algorithm/italiano.h"
#include "algorithm/king.h"
#endif #endif

2
test/decremental_reachability_test.cc
View File

@@ -4,6 +4,8 @@
#include "algorithm/frigioni.h" #include "algorithm/frigioni.h"
#include "algorithm/italiano.h" #include "algorithm/italiano.h"
#include <memory>
using namespace graph; using namespace graph;
TEST_SUITE("Decremental Reachability Test") { TEST_SUITE("Decremental Reachability Test") {

2
test/dynamic_reachability_test.cc
View File

@@ -3,6 +3,8 @@
#include "algorithm/henzinger_king.h" #include "algorithm/henzinger_king.h"
#include "algorithm/king.h" #include "algorithm/king.h"
#include <memory>
using namespace graph; using namespace graph;
TEST_SUITE("Dynamic Reachability Test") { TEST_SUITE("Dynamic Reachability Test") {