Consider a set S of n data points in real d-dimensional space, R d , where distances are measured using any Minkowski metric. In nearest neighbor searching we preprocess S into a data structure, so that given any query point q 2 R d , the closest point of S to q can be reported quickly. Given any positive real ffl, a data point p is a (1 + ffl)-approximate nearest neighbor of q if its distance from q is within a factor of (1 + ffl) of the distance to the true nearest neighbor. We show that it is possible to preprocess a set of n points in R d in O(dn log n) time and O(dn) space, so that given a query point q 2 R d , and ffl ? 0, a (1 + ffl)-approximate nearest neighbor of q can be computed in O(c d;ffl log n) time, where c d;ffl d d1 + 6d=ffle d is a factor depending only on dimension and ffl. In general, we show that given an integer k 1, (1 + ffl)-approximations to the k nearest neighbors of q can be computed in additional O(kd log n) time.

We give a linear-time algorithm for single-source shortest paths in planar graphs with nonnegative edge-lengths. Our algorithm also yields a linear-time algorithm for maximum flow in a planar graph with the source and sink on the same face. The previous best algorithms for these problems required\Omega\Gamma n p log n) time where n is the number of nodes in the input graph. For the case where negative edge-lengths are allowed, we give an algorithm requiring O(n 4=3 log nL) time, where L is the absolute value of the most negative length. Previous algorithms for shortest paths with negative edge-lengths required \Omega\Gamma n 3=2 ) time. Our shortest-path algorithm yields an O(n 4=3 log n)-time algorithm for finding a perfect matching in a planar bipartite graph. A similar improvement is obtained for maximum flow in a directed planar graph.

Deterministic fully dynamic graph algorithms are presented for connectivity and minimum spanning forest. For connectivity, starting with no edges, the amortized cost for maintaining a spanning forest is O(log² n) per update, i.e. per edge insertion or deletion. Deciding connectivity between any two given vertices is done in O(log n= log log n) time. This matches the previous best randomized bounds. The previous best deterministic bound was O( 3 p n log n) amortized time per update but constant time for connectivity queries. For minimum spanning trees, first a deletions-only algorithm is presented supporting deletes in amortized time O(log² n). Applying a general reduction from Henzinger and King, we then get a fully dynamic algorithm such that starting with no edges, the amortized cost for maintaining a minimum spanning forest is O(log^4 n) per update. The previous best deterministic bound was O( 3 p n log n) amortized time per update, and no better randomized bounds were ...

For a set P of n points in R^d, we define a new type of space decomposition. The new diagram provides an ε-approximation to the distance function associated with the Voronoi diagram of P, while being of near linear size, for d ≥ 2. This contrasts with the standard Voronoi diagram that has complexity Ω(n^⌈d/2⌉) in the worst case.

. Ambivalent data structures are presented for several problems on undirected graphs. These data structures are used in finding the k smallest spanning trees of a weighted undirected graph in O(m log #(m, n) + min{k 3/2 ,km 1/2 }) time, where m is the number of edges and n the number of vertices in the graph. The techniques are extended to find the k smallest spanning trees in an embedded planar graph in O(n + k(log n) 3 ) time. Ambivalent data structures are also used to dynamically maintain 2-edge-connectivity information. Edges and vertices can be inserted or deleted in O(m 1/2 ) time, and a query as to whether two vertices are in the same 2-edge-connected component can be answered in O(log n) time, where m and n are understood to be the current number of edges and vertices, respectively. Key words. analysis of algorithms, data structures, embedded planar graph, fully persistent data structures, k smallest spanning trees, minimum spanning tree, on-line updating, topology tr...

We give an efficient algorithm for maintaining a minimum spanning forest of a plane graph subject to on-line modifications. The modifications supported include changes in the edge weights, and insertion and deletion of edges and vertices which are consistent with the given embedding. Our algorithm runs in O(log n) time per operation and O(n) space.

Introduction In many applications of graph algorithms, including communication networks, graphics, assembly planning, and VLSI design, graphs are subject to discrete changes, such as additions or deletions of edges or vertices. In the last decade there has been a growing interest in such dynamically changing graphs, and a whole body of algorithms and data structures for dynamic graphs has been discovered. This chapter is intended as an overview of this field. In a typical dynamic graph problem one would like to answer queries on graphs that are undergoing a sequence of updates, for instance, insertions and deletions of edges and vertices. The goal of a dynamic graph algorithm is to update efficiently the solution of a problem after dynamic changes, rather than having to recompute it from scratch each time. Given their powerful versatility, it is not surprising that dynamic algorithms and dynamic data structures are often more difficult to design and analyze than their static c

Traditionally, computational complexity has considered only static problems. Classical Complexity Classes such as NC, P, and NP are defined in terms of the complexity of checking -- upon presentation of an entire input -- whether the input satisfies a certain property. For many applications of computers it is more appropriate to model the process as a dynamic one. There is a fairly large object being worked on over a period of time. The object is repeatedly modified by users and computations are performed. We develop a theory of Dynamic Complexity. We study the new complexity class, Dynamic First-Order Logic (Dyn-FO). This is the set of properties that can be maintained and queried in first-order logic, i.e. relational calculus, on a relational database. We show that many interesting properties are in Dyn-FO including multiplication, graph connectivity, bipartiteness, and the computation of minimum spanning trees. Note that none of these problems is in static FO, and this f...

We examine the amount of preprocessing needed for answering certain on-line queries as fast as possible. We start with the following basic problem. Suppose we are given a semigroup (S,°). Let s 1,..., sn be elements of S. We want to answer on-line queries of the form, "What is the product s i°s i +1 ° j −1 j n 1... °s °s? " for any give ≤ i ≤ j ≤ n. We show that a preprocessing of Θ(n λ(k,n)) time and space is both necessary and sufficient to answer each such query in at most k steps, for any fixed k. The function λ(k,.) is the inverse of a certain function at the �k /2 �−th level of the prim-itive recursive hierarchy. In case linear preprocessing is desired, we show that one can answer each such query in at most O (α(n)) steps and that this is best possible. The function α(n) is the inverse Ackermann function. We also consider the following extended problem. Let T be a tree with an element of S associated with each of its vertices. We want to answer on-line queries of the form, " What is the product of the elements associated with the vertices along the path from u to v? " for any pair of vertices u and v in T. We derive results, which are similar to the above, for the preprocessing needed for answering such queries. All our sequential preprocessing algorithms can be parallelized efficiently to give optimal parallel algorithms which run in O (logn) time on a CREW PRAM. These parallel algorithms are optimal in both running time and total number of operations.

This paper solves a longstanding open problem in fully dynamic algorithms: We present the first fully dynamic algorithms that maintain connectivity, bipartiteness, and approximate minimum spanning trees in polylogarithmic time per edge insertion or deletion. The algorithms are designed using a new dynamic technique which combines a novel graph decomposition with randomization. They are Las-Vegas type randomized algorithms which use simple data structures and have a small constant factor. Let n denote the number of nodes in the graph. For a sequence of \Omega\Gamma m 0 ) operations, where m 0 is the number of edges in the initial graph, the expected time for p updates is O(p log 3 n) 1 for connectivity and bipartiteness. The worst-case time for one query is O(log n= log log n). For the k-edge witness problem ("Does the removal of k given edges disconnect the graph?") the expected time for p updates is O(p log 3 n) and expected time for q queries is O(qk log 3 n). Given a grap...