We consider how to maintain the topological order of a directed acyclic graph (DAG) in the presence of edge insertions and deletions. We present a new algorithm and, although this has marginally inferior time complexity compared with the best previously known result, we find that its simplicity leads to better performance in practice. In addition, we provide an empirical comparison against three alternatives over a large number of random DAG's. The results show our algorithm is the best for sparse graphs and, surprisingly, that an alternative with poor theoretical complexity performs marginally better on dense graphs.

Abstract not found

ii An External-Memory Data Structure for Shortest Path Queries

We consider how to maintain the topological order of a directed acyclic graph (DAG) in the presence of edge insertions and deletions. We present a new algorithm and obtain a marginally improved complexity result over the previously known O(||#||log||#||). In addition, we provide an empirical comparison against three existing solutions using random DAG's. The results show our algorithm to out perform the others on sparse graphs. Finally, we show how the algorithm can be extended to identify strongly connected components online.

Given a database, the view maintenance problem is concerned with the efficient computation of the new contents of a given view when updates to the database happen. We consider the view maintenance problem for the situation when the database contains a (weighted) graph and the view is either the transitive closure or the answer to the all-pairs shortest-distance problem (APSD). We give incremental algorithms for (APSD), which support both edge insertions and deletions. For transitive closure, the algorithm is applicable to a more general class of graphs than those previously explored. Our algorithms use first-order queries, along with addition (+) and less-than (<) operations (F O(+, <)); they store O(n 2) number of tuples, where n is the number of vertices, and have AC 0 data complexity for integer weights. Since F O(+, <) is a sublanguage of SQL and is supported by almost all current database systems, our maintenance algorithms are more appropriate for database applications than non-database query type of maintenance algorithms.

We perform an extensive experimental study of several dynamic algorithms for transitive closure. In particular, we implemented algorithms given by Italiano, Yellin, Cicerone et al., and two recent randomized algorithms by Henzinger and King. We propose a ne-tuned version of Italiano's algorithms as well as a new variant of them, both of which were always faster than any of the other implementations of the dynamic algorithms. We also considered simpleminded algorithms that were easy to implement and likely to be fast in practice. We tested and compared the above implementations on random inputs, on non-random inputs that are worst-case inputs for the dynamic algorithms, and on an input motivated by a real-world graph.

The girth of a graph G has been de ned as the length of a shortest cycle of G. We design an O(n 5=4 log n) algorithm for finding the girth of an undirected n-vertex planar graph, giving the first o(n 2 ) algorithm for this problem. Our approach combines several techniques such as graph separation, hammock decomposition, covering of a planar graph with graphs of small tree-width, and dynamic shortest path computation. We discuss extensions and generalizations of our result.

Abstract. We consider the issue of maintaining the topological order for a di-rected graph in the presence of edge insertions and deletions. We present a new algorithm and provide empirical data on random graphs comparing it with twoexisting solutions. In addition, we obtain a marginally improved bounded complexity result over the previously known O(jjffijjlogjjffijj). The results show our al-gorithm to perform better than the rest in all situations except very dense graphs. This we attribute to its simplicity and good theoretical complexity. Our motiva-tion for this work arises from efforts to build efficient pointer analyses. 1 Introduction A topological ordering, ord, of a directed acyclic graph G = (V; E) maps each vertex toa priority value such that, for all edges x! y 2 E, it is the case that ord(x) ! ord(y).There exist well known linear time algorithms for computing the topological order of a

Abstract. A (1 + ɛ)-approximate distance oracle for a graph is a data structure that supports approximate point-to-point shortest-path-distance queries. The relevant measures for a distance-oracle construction are: space, query time, and preprocessing time. There are strong distance-oracle constructions known for planar graphs (Thorup) and, subsequently, minor-excluded graphs (Abraham and Gavoille). However, these require Ω(ɛ −1 n lg n) space for n-node graphs. We argue that a very low space requirement is essential. Since modern computer architectures involve hierarchical memory (caches, primary memory, secondary memory), a high memory requirement in effect may greatly increase the actual running time. Moreover, we would like data structures that can be deployed on small mobile devices, such as handhelds, which have relatively small primary memory. In this paper, for planar graphs, bounded-genus graphs, and minorexcluded graphs we give distance-oracle constructions that require only

We provide the first linear-space data structure with provable sublinear query time for exact point-topoint shortest path queries in planar graphs. We prove that for any planar graph G with non-negative arc lengths and for any ɛ> 0 there is a data structure that supports exact shortest path and distance queries in G with the following properties: the data structure can be created in time O(n lg(n) lg(1/ɛ)), the space required is O(n lg(1/ɛ)), and the query time is O(n 1/2+ɛ). Previous data structures by Fakcharoenphol and Rao (JCSS’06), Klein, Mozes, and Weimann (TransAlg’10), and Mozes and Wulff-Nilsen (ESA’10) with query time O(n 1/2 lg 2 n) use space at least Ω(n lg n / lg lg n). We also give a construction with a more general tradeoff. We prove that for any integer S ∈ [n lg n, n 2], we can construct in time Õ(S) a data structure of size O(S) that answers distance queries in O(nS −1/2 lg 2.5 n) time per query. Cabello (SODA’06) gave a comparable construction for the smaller range S ∈ [n 4/3 lg 1/3 n, n 2]. For the range S ∈ (n lg n, n 4/3 lg 1/3 n), only data structures of size O(S) with query time O(n 2 /S) had been known (Djidjev, WG’96). Combined, our results give the best query times for any shortest-path data structure for planar graphs with space S = o(n 4/3 lg 1/3 n). As a consequence, we also obtain an algorithm that computes k–many distances in planar graphs in time O((kn) 2/3 (lg n) 2 (lg lg n) −1/3 + n(lg n) 2 / lg lg n). 1