\thefigure The tree embedding algorithm
\section

Introduction \labelsec:introduction

In this paper we study decremental graph connectivity. In the edge deletion version of the problem, we are initially given an undirected graph , and we can perform two operations: delete, which deletes an edge from the current graph, and connected which returns whether vertices are connected. The vertex deletion version is the same, except that the delete operation is replaced with delete, which deletes a vertex and all of its adjacent edges from the current graph.

The past decade has seen a good deal of effort in finding algorithms and data structures that efficiently support the above operations. However, the current best bounds known are amortized, expected, or even both. In 1992, Eppstein et al. \citeEppGalIta-JACM-97 improved the worst-case bound of Frederickson \cite808754 from to per update, and answering queries in constant time. This remains the best known worst-case bound for decremental connectivity on general graphs. Since then, there has been a number of improvements, in particular the work of Henzinger, King and Thorup \cite320215,280036 who used randomization to obtain Las Vegas algorithms supporting updates in expected amortized time, and answering queries in time. In 1998 Holm et al. \cite502095 obtained a deterministic algorithm with amortized time for updates. However, none of these algorithms break the worst-case barrier, and the amortized bounds are often taken over deleting all edges in a graph.

Our motivation for studying this problem comes from trying to efficiently represent cuts in a graph, and we are interested in the following problem, which we will call GRAPH CUT: given an undirected connected graph , we want to answer queries , which returns ‘no’ iff the set is a -cut in ’ (in the edge cut version of the problem, is a set of edges and is a set of vertices in the vertex cut version). We could answer queries using a fully-dynamic connectivity algorithm, by removing the set and testing connectivity, and then adding again to be ready for the next query, but the current best worst-case time would be .

One interesting application is the ‘forbidden-set’ routing problem for interdomain routing on the Internet \cite. Here, each autonomous system (AS) has a set of other ASes that it wishes to avoid in routing messages, perhaps because perceives these ASes to be unreliable, or because it is a competitor who may drop ’s traffic (in the edge version, would be a set of communication links that wishes to avoid). Furthermore, we expect that the sets will be small, perhaps , but dynamically-changing.

In this paper we take a different approach to decremental connectivity that lets us improve on these worst-case bounds in special cases, in particular when the number of deletions is small, and when the graphs satisfy certain properties such as small cutwidth or path covering number. As far as we know, these are the first dynamic connectivity algorithms that make use of such graph properties, and that are optimised for small numbers of deletions.

\subsection

Planar orthogonal range queries We make use of dynamic algorithms for planar orthogonal range queries to efficiently test for the existence of an edge in the auxiliary graph as follows. Given a linear layout of , an edge of is a point in 2d space. Each vertex of the auxiliary graph represents a connected interval on the layout. Then two vertices are adjacent iff there exists an edge of with endpoints in and iff the box is nonempty. If has vertices and edges, we can test for an edge in in worst-case time , and handle deletions and insertions of edges in worst-case time \cite644210.

\section

Edge deletions

Consider embedding the graph into a tree rather than a line. The tree still has the property that removing any edge disconnects it into two components, so this provides hope that we can efficiently maintain some sort of small auxiliary graph. In this section we give an decremental algorithm that handles the th deletion in time , and queries in time , regardless of the cutwidth or path number of the graph. Furthermore, the algorithm only requires preprocessing time.

The algorithm is most similar to that of Henzinger and King \cite320215, with an exception – instead of maintaining a spanning forest of , we do not bother to patch up tree edges when they are removed. Instead, we keep track of the fragmented parts of the forest as edges are removed (using a dynamic connectivity algorithm) and use this information to efficiently answer the connectivity queries.

initialise
  let T be a spanning tree of G
  number the vertices using a postorder traversal of T
  store the interval of T(v) for each vertex v
  insert edges of G into a range tree using the postorder numbering
  construct a graph H with a single vertex {[1..n]}

delete(u,v)
// assume that v > u, i.e. v is the parent of u
begin
 delete the edge (u,v) from G using the dynamic range tree [time=O(log n)]
 let h(u),h(v) be the intervals containing u,v
 if G has no edge between h(u),h(v) then [time=O(log n)]
 begin
   if h(u) != h(v) then
     delete the edge (h(u),h(v)) from H [time=O(1) using adjacency matrix]
   else
   begin
     let h=h(u)=h(v)
     // split the vertex h
     let [i,j] = T(u), the subtree rooted at u

     let [a,b] be the interval of H containing i
     if (a < i) then
       delete [a,b] from H
       insert [a,i-1],[i,b] into H
       for each neighbour [x,y] of [a,b] in H
         if G has an edge ([x,y],[a,i-1]) then add an edge ([x,y],[a,i-1]) to H
         if G has an edge ([x,y],[i,b]) then add an edge ([x,y],[a,i-1]) to H

     let [c,d] be the interval of H containing j
     if (d > j) then
       delete [c,d] from H
       insert [c,j],[j+1,d] into H
       for each neighbour [x,y] of [c,d] in H
         if G has an edge([x,y],[a,i-1]) then add an edge ([x,y],[a,i-1]) to H
         if G has an edge([x,y],[i,b]) then add an edge ([x,y],[a,i-1]) to H

   end
 end
end

connected(u,v)
  find h(u), h(v) [time=O(log |H|)]
  do a dfs on H [time=O(|H|^2)]
Figure \thefigure: The tree embedding algorithm

The algorithm maintains a graph whose vertices are connected subtrees of , with an edge between two subtrees if there is a nontree edge of between a pair of vertices . Deleting a tree edge where is the parent of and is done by splicing out the interval from the set of intervals covering it, which results in splitting a vertex of . The above implementation stores in adjacency matrix form so that edge updates are . Each tree edge deleted increases the number of vertices of by at most 2, so after deletions has vertices. The th deletion takes worst-case time , and connectivity queries are answered in worst-case time . Alternatively we could use the algorithm of Eppstein to maintain (where each edge deletion or insertion takes worst-case time ), so that the th deletion takes time and connectivity queries are answered in time .

Comments 0
Request Comment
You are adding the first comment!
How to quickly get a good reply:
  • Give credit where it’s due by listing out the positive aspects of a paper before getting into which changes should be made.
  • Be specific in your critique, and provide supporting evidence with appropriate references to substantiate general statements.
  • Your comment should inspire ideas to flow and help the author improves the paper.

The better we are at sharing our knowledge with each other, the faster we move forward.
""
The feedback must be of minimum 40 characters and the title a minimum of 5 characters
   
Add comment
Cancel
Loading ...
15844
This is a comment super asjknd jkasnjk adsnkj
Upvote
Downvote
""
The feedback must be of minumum 40 characters
The feedback must be of minumum 40 characters
Submit
Cancel

You are asking your first question!
How to quickly get a good answer:
  • Keep your question short and to the point
  • Check for grammar or spelling errors.
  • Phrase it like a question
Test
Test description