Engineering DFS-Based Graph Algorithms

Depth-first search (DFS) is the basis for many efficient graph algorithms. We introduce general techniques for the efficient implementation of DFS-based graph algorithms and exemplify them on three algorithms for computing strongly connected components. The techniques lead to speed-ups by a factor of two to three compared to the implementations provided by LEDA and BOOST. We have obtained similar speed-ups for biconnected components algorithms. We also compare the graph data types of LEDA and BOOST

Dynamic fractional cascading

The problem of searching for a key in many ordered lists arises frequently in computational geometry. Chazelle and Guibas recently introduced fractional cascading as a general technique for solving this type of problem. In the present paper we show that fractional cascading also supports insertions into and deletions from the lists efficiently. More specifically, we show that a search for a key in n lists takes time O(log N+nloglogN) and an insertion or deletion takes time O(loglogN). Here N is the total size of all lists. If only insertions or deletions have to be supported the O(loglogN) factor reduces to O(1). As an application we show that queries, insertions and deletions into segment trees or range trees can be supported in t ime O(lognloglogn), when n is the number of segments (points)

A lower bound for the complexity of the union-split-find problem

We prove a Theta(loglog n) (i.e. matching upper and lower) bound on the complexity of the Union-Split-Find problem, a variant of the Union-Find problem. Our lower bound holds for all pointer machine algorithms and does not require the separation assumption used in the lower bound arguments of Tarjan [T79] and Blum [B86]. We complement this with a Theta(log n) bound for the Split-Find problem under the separation assumption. This shows that the separation assumption can imply an exponential loss in efficiency

An Implementation of the Hopcroft and Tarjan Planarity Test and Embedding Algorithm

We describe an implementation of the Hopcroft and Tarjan planarity test and embedding algorithm. The program tests the planarity of the input graph and either constructs a combinatorial embedding (if the graph is planar) or exhibits a Kuratowski subgraph (if the graph is non-planar)

Dynamic fractional cascading

The problem of searching for a key in many ordered lists arises frequently in computational geometry. Chazelle and Guibas recently introduced fractional cascading as a general technique for solving this type of problem. In the present paper we show that fractional cascading also supports insertions into and deletions from the lists efficiently. More specifically, we show that a search for a key in n lists takes time O(log N+nloglogN) and an insertion or deletion takes time O(loglogN). Here N is the total size of all lists. If only insertions or deletions have to be supported the O(loglogN) factor reduces to O(1). As an application we show that queries, insertions and deletions into segment trees or range trees can be supported in t ime O(lognloglogn), when n is the number of segments (points)

LEDA : a library of efficient data types and algorithms

LEDA is a library of efficient data types and algorithms. At present, its strength is graph algorithms and related data structures. The computational geometry part is evolving. The main features of the library are 1) a clear separation of specification and implementation 2) parameterized data types 3) a comfortable data type graph, 4) its extendibility, and 5) its ease of use

From Algorithms to Working Programs On the Use of Program Checking in LEDA

We report on the use of program checking in the LEDA library of efficient data types and algorithms

Implementation of a Sweep Line Algorithm for the Straight Line Segment Intersection Problem

We describe a robust and efficient implementation of the Bentley-Ottmann sweep line algorithm [7] based on the LEDA library of efficient data types and algorithms [7]. The program computes the planar graph G induced by a set S of straight line segments in the plane. The nodes of G are all endpoints and all proper intersection points of segments in S. The edges of G are the maximal relatively open subsegments of segments in S that contain no node of G. All edges are directed from left to right or upwards. The algorithm runs in time O((n + s) log n) where n is the number of segments and s is the number of vertices of the graph G. The implementation uses exact arithmetic for the reliable realization of the geometric primitives and it uses floating point filters to reduce the overhead of exact arithmetic