79 lines
2.4 KiB
C++
79 lines
2.4 KiB
C++
#ifndef HENZINGER_KING_H_
|
|
#define HENZINGER_KING_H_
|
|
|
|
#include "algorithm/dynamic_reachability.h"
|
|
#include "algorithm/frigioni.h"
|
|
|
|
using namespace graph;
|
|
|
|
namespace algo {
|
|
|
|
template<typename T>
|
|
class HenzingerKing : public DynamicReachability<T> {
|
|
public:
|
|
HenzingerKing() = default;
|
|
|
|
HenzingerKing(Digraph<T> G) { this->G = G; }
|
|
|
|
// 1. Initialize a decremental reachability data structure.
|
|
// 2. Let S <- phi.
|
|
|
|
// In the beginning of each phase, a decremental reachability data structure
|
|
// is initialized. We let S be the set of vertices that were centers of
|
|
// insertions during this phase. Initially S = phi. When a set of edges Ev, all
|
|
// touching v, is inserted, we add v to S and construct reachability trees In(v)
|
|
// and Out(v) rooted at v. When the size of S, the set of insertion centers,
|
|
// reaches t, a parameter fixed in advance, the phase is declared over, and
|
|
// all the data structures are reinitialized.
|
|
void init() override;
|
|
|
|
// 1. Query the decremental reachability data structure.
|
|
// 2. For each w in S check if u in In(w) and v in Out(w).
|
|
|
|
// First the decremental data structure is queried to see whether there is a
|
|
// directed path from u to v composed solely of edges that were present in the
|
|
// graph at the start of the current phase. If not, it is checked whether there
|
|
// exists w in S such that u in In(w) and v in Out(w). If such a vertex w exists,
|
|
// then the answer is YES.
|
|
bool query(const T& u, const T& v) override;
|
|
|
|
// 1. Let E <- E - E'.
|
|
// 2. Delete E' from the decremental data structure.
|
|
// 3. For every w in S, rebuilt the trees In(w) and Out(w).
|
|
|
|
// First, the edges of E' are removed from the decremental data structure. Next,
|
|
// for every w in S, the shortest-paths trees In(w) and Out(w) are built from
|
|
// scratch.
|
|
void remove(const T& u, const T& v) override;
|
|
|
|
// 1. Let E <- E union Ev.
|
|
// 2. Let S <- S union {v}.
|
|
// 3. If |S| > t, then call init.
|
|
// 4. Otherwise, construct the trees In(v) and Out(v).
|
|
void insert(const T& u, const T& v) override;
|
|
};
|
|
|
|
template<typename T>
|
|
void HenzingerKing<T>::init() {
|
|
|
|
}
|
|
|
|
template<typename T>
|
|
bool HenzingerKing<T>::query(const T& u, const T& v) {
|
|
|
|
return false;
|
|
}
|
|
|
|
template<typename T>
|
|
void HenzingerKing<T>::remove(const T& u, const T& v) {
|
|
|
|
}
|
|
|
|
template<typename T>
|
|
void HenzingerKing<T>::insert(const T& u, const T& v) {
|
|
|
|
}
|
|
|
|
} // namespace algo
|
|
|
|
#endif |