Linear-Time Algorithms for Geometric Graphs with Sublinearly Many Edge Crossings

We provide linear-time algorithms for geometric graphs with sublinearly many crossings. That is, we provide algorithms running in O(n) time on connected geometric graphs having n vertices and k crossings, where k is smaller than n by an iterated logarithmic factor. Specific problems we study include Voronoi diagrams and single-source shortest paths. Our algorithms all run in linear time in the standard comparison-based computational model; hence, we make no assumptions about the distribution or bit complexities of edge weights, nor do we utilize unusual bit-level operations on memory words. Instead, our algorithms are based on a planarization method that "zeroes in" on edge crossings, together with methods for extending planar separator decompositions to geometric graphs with sublinearly many crossings. Incidentally, our planarization algorithm also solves an open computational geometry problem of Chazelle for triangulating a self-intersecting polygonal chain having n segments and k crossings in linear time, for the case when k is sublinear in n by an iterated logarithmic factor.Comment: Expanded version of a paper appearing at the 20th ACM-SIAM Symposium on Discrete Algorithms (SODA09

A Randomized Algorithm for Single-Source Shortest Path on Undirected Real-Weighted Graphs

In undirected graphs with real non-negative weights, we give a new randomized algorithm for the single-source shortest path (SSSP) problem with running time $O(m\sqrt{\log n \cdot \log\log n})$ in the comparison-addition model. This is the first algorithm to break the $O(m+n\log n)$ time bound for real-weighted sparse graphs by Dijkstra's algorithm with Fibonacci heaps. Previous undirected non-negative SSSP algorithms give time bound of $O(m\alpha(m,n)+\min\{n\log n, n\log\log r\})$ in comparison-addition model, where $\alpha$ is the inverse-Ackermann function and $r$ is the ratio of the maximum-to-minimum edge weight [Pettie & Ramachandran 2005], and linear time for integer edge weights in RAM model [Thorup 1999]. Note that there is a proposed complexity lower bound of $\Omega(m+\min\{n\log n, n\log\log r\})$ for hierarchy-based algorithms for undirected real-weighted SSSP [Pettie & Ramachandran 2005], but our algorithm does not obey the properties required for that lower bound. As a non-hierarchy-based approach, our algorithm shows great advantage with much simpler structure, and is much easier to implement.Comment: 17 page

Integer priority queues with decrease key in constant time and the single source shortest paths problem

AbstractWe consider Fibonacci heap style integer priority queues supporting find-min, insert, and decrease key operations in constant time. We present a deterministic linear space solution that with n integer keys supports delete in O(loglogn) time. If the integers are in the range [0,N), we can also support delete in O(loglogN) time.Even for the special case of monotone priority queues, where the minimum has to be non-decreasing, the best previous bounds on delete were O((logn)1/(3−ε)) and O((logN)1/(4−ε)). These previous bounds used both randomization and amortization. Our new bounds are deterministic, worst-case, with no restriction to monotonicity, and exponentially faster.As a classical application, for a directed graph with n nodes and m edges with non-negative integer weights, we get single source shortest paths in O(m+nloglogn) time, or O(m+nloglogC) if C is the maximal edge weight. The latter solves an open problem of Ahuja, Mehlhorn, Orlin, and Tarjan from 1990

Negative-Weight Single-Source Shortest Paths in Near-Linear Time: Now Faster!

In this work we revisit the fundamental Single-Source Shortest Paths (SSSP) problem with possibly negative edge weights. A recent breakthrough result by Bernstein, Nanongkai and Wulff-Nilsen established a near-linear $O(m \log^8(n) \log(W))$-time algorithm for negative-weight SSSP, where $W$ is an upper bound on the magnitude of the smallest negative-weight edge. In this work we improve the running time to $O(m \log^2(n) \log(nW) \log\log n)$, which is an improvement by nearly six log-factors. Some of these log-factors are easy to shave (e.g. replacing the priority queue used in Dijkstra's algorithm), while others are significantly more involved (e.g. to find negative cycles we design an algorithm reminiscent of noisy binary search and analyze it with drift analysis). As side results, we obtain an algorithm to compute the minimum cycle mean in the same running time as well as a new construction for computing Low-Diameter Decompositions in directed graphs

Proceedings of the Resolve Workshop 2006

The aim of the RESOLVE Workshop 2006 was to bring together researchers and educators interested in: Refining formal approaches to software engineering, especially component-based systems, and introducing them into the classroom. The workshop served as a forum for participants to present and discuss recent advances, trends, and concerns in these areas, as well as formulate a common understanding of emerging research issues and possible solution paths

Modifying Dijkstra's Algorithm to Solve Many Instances of SSSP in Linear Time

We show that for graphs with positive edge weights the single-source shortest path planning problem (SSSP) can be solved using a novel partial ordering over nodes, instead of a full ordering, without sacrificing algorithmic correctness. The partial ordering we investigate is defined with respect to carefully chosen (but easy to calculate) "approximate" level-sets of shortest-path length. We present a family of easy-to-implement "approximate'' priority heaps, based on an array of linked-lists, that create this partial ordering automatically when used directly by Dijkstra's SSSP algorithm. For graphs G = (E,V) with positive edge lengths, and depending on which version of the heap is used, the resulting Dijkstra variant runs in either time O(|E| + |V | + K) with space O(|E| + |V | + l_max/l_min) or time O((|E| + |V|) log_w(l_max/l_min + 1)) with space O(|E| + log_w(l_max/l_min + 1)), where l_min and l_max are the minimum (non-zero) and maximum (finite) edge lengths, respectively, and w is the word length of the computer being used (e.g., 32 or 64 in most cases), and K is a function of G such that K = O(|E|) for many common types of graphs (e.g., K = 1 for graphs with unit edge lengths). We also describe a linear time pre-/post-processing procedure that extends these results to undirected graphs with non-negative edge weights. Thus, it possible to solve many instances of SSSP in O(|E| + |V |); for these instances our method ties the fastest known runtime for SSSP, while having smaller constant factor overhead than previous methods. This work can be viewed as an extension of Dial’s SSSP algorithm in order handle floating point edge weights, faster runtimes, and new theoretical results