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

Improve readability

Browse Source
This commit is contained in:
stefiosif
2023-02-10 18:26:48 +02:00
parent 2175ac0ca9
commit 3591c58f6d
6 changed files with 217 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/algorithm/breadth_first_search.h
View File

@@ -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

235
include/algorithm/frigioni.h
View File

@@ -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 });
}
}
}

71
include/algorithm/italiano.h
View File

@@ -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);
}
}
}

27
include/algorithm/roditty_zwick.h
View File

@@ -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]);
}

24
include/algorithm/tarjan.h
View File

@@ -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;

16
include/graph/breadth_first_tree.h
View File

@@ -15,7 +15,9 @@ public:
BreadthFirstTree(Digraph<T> G, T root);
T root;
void removeEdgeTo(const T& u);
T root{};
};
template<typename T>
@@ -23,6 +25,18 @@ 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]) {
if (y == u) {
this->remove(x, u);
return;
}
}
}
}
} // namespace graph
#endif