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.

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.

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.

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 .