1. Reachability in Directed Graphs
Liam Roditty

2. Connectivity in undirected graphs
Given two vertices decide whether they are in the same component.
G = (V,E) u v ṽ ũ
G = (V,E) u v ṽ ũ
G = (V,E) u v ṽ ũ
Reachability
Is there a directed
path from u to v
Strong Connectivity
Is there a directed
path from u to v
and from v to u

3. Dynamic graph algorithms
Strong Connectivity

4. Fully dynamic reachability4 1 5 2 3
Reachability
1,4 ?
1,2 ?
Yes No
Yes

5. Decremental Reachability
Total
update
time
PvL87,
FMNZ01 m2
DI’ 00 n3
BHS’ 00
mn4/3
HK’ 95
RZ’ 02
I’ 88
Just for DAGs mn t 1
n/log n m
Query
time

6. Fully dynamic reachability
Small Query Time:
Maintain explicitly the transitive closure matrix.
Query is done in O(1), each update may take (n2)
time.

7. Fully dynamic reachability
Small Query Time:
Maintain explicitly the transitive closure matrix.
Query is done in O(1), each update may take (n2)
time.
Small Update Time:
A data structure which may have a non-constant
query time but with smaller update time.
Open problem:
Is it possible to break the (n2) update barrier ?
Yes: Updates in O(m+n log n) and queries in O(n)

8. Fully Dynamic Reachability
Update
time
General
graphs mn t
RZ’ 03 m n  n2 n 
m+n logn
Today
DI’ 00
R’ 03
S’04 n2
DI’ 00
DAG
n1.575 n  n t n 
n0.575 1 n m
Query
time

9. An overview of the algorithm
Our algorithm supports the following operations:
Insert(Ew) – Insert the edges Ew all touching w into the graph
Delete(E’ ) – Delete all edges of E’ from the graph
Query(u,v) – Check whether there is a directed path from u to v
Insert(Ev)
Insert(Eu)
G(V,E0)
G(V,E0Ev)
G(V,E0Ev Eu)

10. An overview of the algorithm
Insert(Ev)
Insert(Eu) v x y u
G(V,E0)
G(V,E0Ev)
G(V,E0Ev Eu) v x y
Our algorithm works as follows:
Insert( Ew ) : Create two trees to capture new paths
Query(u ,v ): w, u  Tin(w)  v  Tout(w)
Delete( E’ ): Delete E’ from all trees

11. An overview of the algorithm
In(v1) … v1 v2 v3 vl
Out(v1)
Insert(Ev1)
Insert(Ev2)
Insert(Ev3)
Insert(Evl)
The main problem is to delete edges efficiently from this forest.

12. A simple solution for DAGs… v1 v2 v3 vl
The total time required to maintain a decremental single source reachability (DSSR) tree in directed acyclic graph is only O(m) (Itliano ’88)  Each edge is scanned only once in each tree
Insert( Ew )
Query(u ,v)
Delete( E’ )
O (n )
O (1 )
O (m+n)

13. Decremental reachability tree
Tin(v) v v
Tout(v)
Every edge is examined only once! (If the graph is DAG)
Total complexity is O(m).

14. The problem with general graphs… v1 v2 v3 vl
There is not any obvious way to generalize Itliano’s algorithm to general graphs. The best algorithm for DSSR requires O(mn) time.
Insert( Ew )
Query(u ,v)
Delete( E’ )
O (n )
O (1 )
O (mn)
O (m+n log n)
O (n )
O (m+n log n)

15. Our Solution … Maintain the trees with respect tov1 v2 v3 vl
Maintain the trees with respect to
Strongly Connected Components
Problem 1: We may have n trees each with different components!
Problem 2: When a component is
decomposed we have to update
the edges such that an edge is
never examine twice!

16. We solve Problem 1 using fully dynamic strong connectivity algorithm with update time of O(m(m,n)).
Detect and report
on decompositions
Fully dynamic strong
connectivity with
“persistency” v1
In(v1)
Out(v1) v5
In(v5)
Out(v5) v4
In(v4)
Out(v4) v2
In(v2)
Out(v2) v3
In(v3)
Out(v3)
Updating edge
lists
Updating edge
lists

17. Fully dynamic strong connectivity
Supported operations:
O (m(m,n))
Insert( E’ ) – Create a new version and add E’ to it.
Delete( E’ ) – Delete the set E’ from all versions.
O (m(m,n))
Query(u,v,i) – Are u and v in the same component in Gi
O (1 )
Insert(E’)
Insert(E’’)
G0=(V,E0)
G0=(V,E0)
G1=(V,E0UE’)
G1=(V,E1)
G1=(V,E1)
G2=(V,E1UE’’)
G2=(V,E2)
Note that these operations create a graph sequence
G0(V,E0), G1(V,E1), … , Gt(V,Et) where E0  E1 …  Et .
This containment is kept during all the update operations!

18. Fully dynamic strong connectivity
The components of all the graphs in the sequence are arranged in a hierarchy and can be represented as a forest of size O (n )
The components:
The forest: G0 G1 G2 G3 G0 G1 G2 G3 1
Version tag u 1 2 v 1 3
Query(u,v,1)  Version( LCA(u,v) )  1
Query(u,v,2)  Version( LCA(u,v) )  2

19. A new partitioning of the edges E1,…, Et
Definition 1: A partitioning of the graph sequence edges
Hi = { (u,v) Ei | Query(u,v,i)  (Query(u,v,i-1)(u,v)Ei-1) }
Ht+1 = Et \ U Hi t
i=1
Gi-1=(V,Ei-1)
Gi+1=(V,Ei+1) Hi
Hi+1
Gi=(V,Ei)
t+1
Hi Hj = ø,Et = U Hi U
i=1

20. Cost Analysis: Note that an edge enters and leave Hi just once
Processing
a deletion
FindScc(H1,1)
FindScc(H2,2)
FindScc(H3,3)
Shift(H1,H2)
Shift(H2,H3)
Shift(H3,H4) G0 G1 G2 G3
Hi edges
Before…
After !
Cost Analysis: Note that an edge enters and leave Hi just once
Moving edges – Paid by the creation of the version they enter. Free
Fixed edges – Paid by the current delete operation O(m)

21. Cost Analysis: Note that an edge enters and leave Hi just once
Processing
a deletion
FindScc(H1,1)
FindScc(H2,2)
FindScc(H3,3)
Shift(H1,H2)
Shift(H2,H3)
Shift(H3,H4) G0 G1 G2 G3
Hi edges
Before…
After !
Cost Analysis: Note that an edge enters and leave Hi just once
Moving edges – Paid by the creation of the version they enter. Free
Fixed edges – Paid by the current delete operation O(m)

22. The component forest G0 G1 G2 G3

23. We solve Problem 1 using fully dynamic strong connectivity algorithm with update time of O(m(m,n)).
Detect and report
on decompositions
Fully dynamic strong
connectivity with
“persistency” v1
In(v1)
Out(v1) v5
In(v5)
Out(v5) v4
In(v4)
Out(v4) v2
In(v2)
Out(v2) v3
In(v3)
Out(v3)
Updating edge
lists
Updating edge
lists

24. Decremental reachability tree
When a decomposition is reported (by the strong
connectivity algorithm), we need to:
Build the data for the new components
Connect the new components to the tree
O(n log n)
O(m)

25. Decremental reachability tree Data structures
The list in[v] contains only uninspected incoming edges.
The list out[v] contains all the outgoing edge.
A vertex v is active if in[v] is not empty
Every component maintains a list of its active vertices
component v
in[v]
Tree invariant: The first edge of the first vertex in the component active vertices list is the edge that connects the component to the tree. If the component is not connected then its active vertices list is empty

26. Decremental reachability tree Edge deletion
- An uninspected incoming edge
- An active vertex
- A tree edge
- A none active vertex
- A deleted edge
component
Deletions of a tree edge – we search for an edge (u,v) such that the component that contains u satisfies the tree invariant
Deletions of non tree edges

27. Decremental reachability tree Disconnecting a component
- An uninspected incoming edge
- An active vertex
- A tree edge
- A none active vertex
- A deleted edge
component
Disconnecting a component.
How do we find the components vertices ?

28. The component forest
component G0 G1 G2 G3
Out[u] u

29. Decremental reachability tree
We generalized the decremented reachability tree to general graphs by using the components of the graph.
Each edge in the connection process is still scanned only once.
We have to deal with decomposition.
We like to create active lists for new components in efficient way.

30. Decremental reachability tree Decomposition
component
Component2
Size = 5
Component1
Size =2
The component decomposed to two new components one of size 5 and one of size 2.
The largest components among the new components inherits
the list of the decomposed component.
Using the component forest each vertex from a small component is removed from the list and added to its new component list.

31. Decremental reachability tree Analysis
Component2
Size = 5
Component1
Size =2
Let’s analyze the total cost:
If a vertex is moved from one active list to another, the size of the component containing it must have decreased by a factor of at least 2.
Scanning the component vertices can be done in time proportional to the component size. We only scan ‘small’ components.
Thus, the total time
is only O(n log n) !

32. Summing up The total connection cost is O(m)
For each tree
The total connection cost is O(m)
The total decomposition cost is O(n log n)
Each update costs O(m + n log n)

33. Open problems Reduce the query time to m/n ?
Reduce the update time to O(m+n) ?
Design other fully dynamic algorithm for a graph sequence ?
A single decremental reachability tree in general graph in o(mn) ?