Loukas Georgiadis

Linear-Time Algorithms for Dominators and Other Path-Evaluation Problems

We present linear-time algorithms for the classic problem of finding dominators in a flowgraph, and for several other problems whose solutions require evaluating a function defined on paths in a tree. Although all these problems had linear-time solutions previously, our algorithms are simpler, in some cases substantially. Our improvements come from three new ideas: a refined analysis of path compression that gives a linear bound if the compressions favor certain nodes; replacement of random-access table look-up by a radix sort; and a more careful partitioning of a tree into easily managed parts. In addition to finding dominators, our algorithms find nearest common ancestors off-line, verify and construct minimum spanning trees, do interval analysis of a flowgraph, and build the component tree of a weighted tree. Our algorithms do not require the power of a random-access machine; they run in linear time on a pointer machine. The genesis of our work was the discovery of a subtle error in the analysis of a previous allegedly linear-time algorithm for finding dominators. That algorithm was an attempt to simplify a more complicated algorithm, which itself was intended to correct errors in a yet earlier algorithm. Our work provides a systematic study of the subtleties in the dominators problem, the techniques needed to solve it in linear time, and the range of application of the resulting methods. We have tried to make our techniques as simple and as general as possible and to understand exactly how earlier approaches to the dominators problem were either incorrect or overly complicated.

Testing 2-vertex connectivity and computing pairs of vertex-disjoint s-t paths in digraphs

We present an O(m+n)-time algorithm that tests if a given directed graph is 2-vertex connected, where m is the number of arcs and n is the number of vertices. Based on this result we design an O(n)- space data structure that can compute in O(log2 n) time two internally vertex-disjoint paths from s to t, for any pair of query vertices s and t of a 2-vertex connected directed graph. The two paths can be reported in additional O(k) time, where k is their total length.

2-Edge Connectivity in Directed Graphs

Edge and vertex connectivity are fundamental concepts in graph theory. While they have been thoroughly studied in the case of undirected graphs, surprisingly, not much has been investigated for directed graphs. In this article, we study 2-edge connectivity problems in directed graphs and, in particular, we consider the computation of the following natural relation: We say that two vertices v and w are 2-edge-connected if there are two edge-disjoint paths from v to w and two edge-disjoint paths from w to v. This relation partitions the vertices into blocks such that all vertices in the same block are 2-edge-connected. Differently from the undirected case, those blocks do not correspond to the 2-edge-connected components of the graph. The main result of this article is an algorithm for computing the 2-edge-connected blocks of a directed graph in linear time. Besides being asymptotically optimal, our algorithm improves significantly over previous bounds. Once the 2-edge-connected blocks are available, we can test in constant time if two vertices are 2-edge-connected. Additionally, when two query vertices v and w are not 2-edge-connected, we can produce in constant time a “witness” of this property by exhibiting an edge that is contained in all paths from v to w or in all paths from w to v. We are also able to compute in linear time a sparse certificate for this relation, i.e., a subgraph of the input graph that has O(n) edges and maintains the same 2-edge-connected blocks as the input graph, where n is the number of vertices.

Improved Dynamic Planar Point Location

We develop the first linear-space data structures for dynamic planar point location in general subdivisions that achieve logarithmic query time and poly-logarithmic update time

An O(nlogn) version of the Averbakh-Berman algorithm for the robust median of a tree

We show that the minmax regret median of a tree can be found in O(nlogn) time. This is obtained by a modification of Averbakh and Bermans O(nlog^2n)-time algorithm: we design a dynamic solution to their bottleneck subproblem of finding the middle of every root-leaf path in a tree.

Dynamic matchings in convex bipartite graphs

We consider the problem of maintaining a maximum matching in a convex bipartite graph G = (V,E) under a set of update operations which includes insertions and deletions of vertices and edges. It is not hard to show that it is impossible to maintain an explicit representation of a maximum matching in sub-linear time per operation, even in the amortized sense. Despite this difficulty, we develop a data structure which maintains the set of vertices that participate in a maximum matching in O(log2 |V|) amortized time per update and reports the status of a vertex (matched or unmatched) in constant worst-case time. Our structure can report the mate of a matched vertex in the maximum matching in worst-case O(min{k log2 |V |+log |V|, |V| log |V|}) time, where k is the number of update operations since the last query for the same pair of vertices was made. In addition, we give an O(√|V| log2 |V|)-time amortized bound for this pair query.

Approximating the smallest 2-vertex connected spanning subgraph of a directed graph

We consider the problem of approximating the smallest 2vertex connected spanning subgraph (2-VCSS) of a 2-vertex connected directed graph, and explore the efficiency of fast heuristics. First, we present a linear-time heuristic that gives a 3-approximation of the smallest 2-VCSS. Then we show that this heuristic can be combined with an algorithm of Cheriyan and Thurimella that achieves a (1 + 1/k)approximation of the smallest k-VCSS. The combined algorithm preserves the 1.5 approximation guarantee of the Cheriyan-Thurimella algorithm for k = 2 and improves its running time from O(m) to O(m √ n+ n), for a digraph with n vertices and m arcs. Finally, we present an experimental evaluation of the above algorithms for a variety of input data. The experimental results show that our linear-time heuristic achieves in practice a much better approximation ratio than 3, suggesting that a tighter analysis may be possible. Furthermore, the experiments show that the combined algorithm not only improves the running time of the Cheriyan-Thurimella algorithm, but it may also compute a smaller 2VCSS.

Finding Dominators in Practice

The computation of dominators in a flowgraph has applications in program optimization, circuit testing, and other areas. Lengauer and Tarjan [17] proposed two versions of a fast algorithm for finding dominators and compared them experimentally with an iterative bit vector algorithm. They concluded that both versions of their algorithm were much faster than the bit-vector algorithm even on graphs of moderate size. Recently Cooper et al. [9] have proposed a new, simple, tree-based iterative algorithm. Their experiments suggested that it was faster than the simple version of the Lengauer-Tarjan algorithm on graphs representing computer program control flow. Motivated by the work of Cooper et al., we present an experimental study comparing their algorithm (and some variants) with careful implementations of both versions of the Lengauer-Tarjan algorithm and with a new hybrid algorithm. Our results suggest that, although the performance of all the algorithms is similar, the most consistently fast are the simple Lengauer-Tarjan algorithm and the hybrid algorithm, and their advantage increases as the graph gets bigger or more complicated.

Shortest-path feasibility algorithms: An experimental evaluation

This is an experimental study of algorithms for the shortest-path feasibility problem: Given a directed weighted graph, find a negative cycle or present a short proof that none exists. We study previously known and new algorithms. Our testbed is more extensive than those previously used, including both static and incremental problems, as well as worst-case instances. We show that, while no single algorithm dominates, a small subset (including new algorithms) has very robust performance in practice. Our work advances the state of the art in the area.

Dominators, directed bipolar orders, and independent spanning trees

We consider problems related to dominators and independent spanning trees in flowgraphs and provide linear-time algorithms for their solutions. We introduce the notion of a directed bipolar order, generalizing a previous notion of Plein and Cheriyan and Reif. We show how to construct such an order from information computed by several known algorithms for finding dominators. We show how to concurrently verify the correctness of a dominator tree D and a directed bipolar order O very simply, and how to construct from D and O two spanning trees whose paths are disjoint except for common dominators. Finally, we describe alternative ways to verify dominators without using a directed bipolar order.