Gerth Stølting Brodal

Algorithms – ESA 2005

Designing Reliable Algorithms in Unreliable Memories.- From Balanced Graph Partitioning to Balanced Metric Labeling.- Fearful Symmetries: Quantum Computing, Factoring, and Graph Isomorphism.- Exploring an Unknown Graph Efficiently.- Online Routing in Faulty Meshes with Sub-linear Comparative Time and Traffic Ratio.- Heuristic Improvements for Computing Maximum Multicommodity Flow and Minimum Multicut.- Relax-and-Cut for Capacitated Network Design.- On the Price of Anarchy and Stability of Correlated Equilibria of Linear Congestion Games,,.- The Complexity of Games on Highly Regular Graphs.- Computing Equilibrium Prices: Does Theory Meet Practice?.- Efficient Exact Algorithms on Planar Graphs: Exploiting Sphere Cut Branch Decompositions.- An Algorithm for the SAT Problem for Formulae of Linear Length.- Linear-Time Enumeration of Isolated Cliques.- Finding Shortest Non-separating and Non-contractible Cycles for Topologically Embedded Graphs.- Delineating Boundaries for Imprecise Regions.- Exacus: Efficient and Exact Algorithms for Curves and Surfaces.- Min Sum Clustering with Penalties.- Improved Approximation Algorithms for Metric Max TSP.- Unbalanced Graph Cuts.- Low Degree Connectivity in Ad-Hoc Networks.- 5-Regular Graphs are 3-Colorable with Positive Probability.- Optimal Integer Alphabetic Trees in Linear Time.- Predecessor Queries in Constant Time?.- An Algorithm for Node-Capacitated Ring Routing.- On Degree Constrained Shortest Paths.- A New Template for Solving p-Median Problems for Trees in Sub-quadratic Time.- Roll Cutting in the Curtain Industry.- Space Efficient Algorithms for the Burrows-Wheeler Backtransformation.- Cache-Oblivious Comparison-Based Algorithms on Multisets.- Oblivious vs. Distribution-Based Sorting: An Experimental Evaluation.- Allocating Memory in a Lock-Free Manner.- Generating Realistic Terrains with Higher-Order Delaunay Triangulations.- I/O-Efficient Construction of Constrained Delaunay Triangulations.- Convex Hull and Voronoi Diagram of Additively Weighted Points.- New Tools and Simpler Algorithms for Branchwidth.- Treewidth Lower Bounds with Brambles.- Minimal Interval Completions.- A 2-Approximation Algorithm for Sorting by Prefix Reversals.- Approximating the 2-Interval Pattern Problem.- A Loopless Gray Code for Minimal Signed-Binary Representations.- Efficient Approximation Schemes for Geometric Problems?.- Geometric Clustering to Minimize the Sum of Cluster Sizes.- Approximation Schemes for Minimum 2-Connected Spanning Subgraphs in Weighted Planar Graphs.- Packet Routing and Information Gathering in Lines, Rings and Trees.- Jitter Regulation for Multiple Streams.- Efficient c-Oriented Range Searching with DOP-Trees.- Matching Point Sets with Respect to the Earth Movers Distance.- Small Stretch Spanners on Dynamic Graphs.- An Experimental Study of Algorithms for Fully Dynamic Transitive Closure.- Experimental Study of Geometric t-Spanners.- Highway Hierarchies Hasten Exact Shortest Path Queries.- Preemptive Scheduling of Independent Jobs on Identical Parallel Machines Subject to Migration Delays.- Fairness-Free Periodic Scheduling with Vacations.- Online Bin Packing with Cardinality Constraints.- Fast Monotone 3-Approximation Algorithm for Scheduling Related Machines.- Engineering Planar Separator Algorithms.- Stxxl: Standard Template Library for XXL Data Sets.- Negative Cycle Detection Problem.- An Optimal Algorithm for Querying Priced Information: Monotone Boolean Functions and Game Trees.- Online View Maintenance Under a Response-Time Constraint.- Online Primal-Dual Algorithms for Covering and Packing Problems.- Efficient Algorithms for Shared Backup Allocation in Networks with Partial Information.- Using Fractional Primal-Dual to Schedule Split Intervals with Demands.- An Approximation Algorithm for the Minimum Latency Set Cover Problem.- Workload-Optimal Histograms on Streams.- Finding Frequent Patterns in a String in Sublinear Time.- Online Occlusion Culling.- Shortest Paths in Matrix Multiplication Time.- Computing Common Intervals of K Permutations, with Applications to Modular Decomposition of Graphs.- Greedy Routing in Tree-Decomposed Graphs.- Making Chord Robust to Byzantine Attacks.- Bucket Game with Applications to Set Multicover and Dynamic Page Migration.- Bootstrapping a Hop-Optimal Network in the Weak Sensor Model.- Approximating Integer Quadratic Programs and MAXCUT in Subdense Graphs.- A Cutting Planes Algorithm Based Upon a Semidefinite Relaxation for the Quadratic Assignment Problem.- Approximation Complexity of min-max (Regret) Versions of Shortest Path, Spanning Tree, and Knapsack.- Robust Approximate Zeros.- Optimizing a 2D Function Satisfying Unimodality Properties.

Dynamic planar convex hull

In this paper we determine the computational complexity of the dynamic convex hull problem in the planar case. We present a data structure that maintains a finite set of n points in the plane under insertion and deletion of points in amortized O(log n) time per operation. The space usage of the data structure is O(n). The data structure supports extreme point queries in a given direction, tangent queries through a given point, and queries for the neighboring points on the convex hull in O(log n) time. The extreme point queries can be used to decide whether or not a given line intersects the convex hull, and the tangent queries to determine whether a given point is inside the convex hull. We give a lower bound on the amortized asymptotic time complexity that matches the performance of this data structure.

On external-memory MST, SSSP and multi-way planar graph separation

Recently external memory graph problems have received considerable attention because massive graphs arise naturally in many applications involving massive data sets. Even though a large number of I/O-efficient graph algorithms have been developed, a number of fundamental problems still remain open.The results in this paper fall in two main classes. First we develop an improved algorithm for the problem of computing a minimum spanning tree (MST) of a general undirected graph. Second we show that on planar undirected graphs the problems of computing a multi-way graph separation and single source shortest paths (SSSP) can be reduced I/O-efficiently to planar breadth-first search (BFS). Since BFS can be trivially reduced to SSSP by assigning all edges weight one, it follows that in external memory planar BFS, SSSP, and multi-way separation are equivalent. That is, if any of these problems can be solved I/O-efficiently, then all of them can be solved I/O-efficiently in the same bound. Our planar graph results have subsequently been used to obtain I/O-efficient algorithms for all fundamental problems on planar undirected graphs.

Time-dependent networks as models to achieve fast exact time-table queries

Abstract We consider efficient algorithms for exact time-table queries, i.e. algorithms that find optimal itineraries for travelers using a train system. We propose to use time-dependent networks as a model and show advantages of this approach over space-time networks as models.

On the limits of cache-obliviousness

In this paper, we present lower bounds for permuting and sorting in the cache-oblivious model. We prove that (1) I/O optimal cache-oblivious comparison based sorting is not possible without a tall cache assumption, and (2) there does not exist an I/O optimal cache-oblivious algorithm for permuting, not even in the presence of a tall cache assumption.Our results for sorting show the existence of an inherent trade-off in the cache-oblivious model between the strength of the tall cache assumption and the overhead for the case M » B, and show that Funnelsort and recursive binary mergesort are optimal algorithms in the sense that they attain this trade-off.

Funnel Heap - A Cache Oblivious Priority Queue

The cache oblivious model of computation is a two-level memory model with the assumption that the parameters of the model are unknown to the algorithms. A consequence of this assumption is that an algorithm efficient in the cache oblivious model is automatically efficient in a multi-level memory model. Arge et al. recently presented the first optimal cache oblivious priority queue, and demonstrated the importance of this result by providingthe first cache oblivious algorithms for graph problems. Their structure uses cache oblivious sorting and selection as subroutines. In this paper, we devise an alternative optimal cache oblivious priority queue based only on binary merging. We also show that our structure can be made adaptive to different usage profiles.

Optimal static range reporting in one dimension

We consider static one dimensional range searching problems. These problems are to build static data structures for an integer set <italic>S</italic> \subseteq <italic>U</italic>, where <italic>U</italic> = \{0,1,\dots,2^<italic>w</italic>-1\}, which support various queries for integer intervals of <italic>U</italic>. For the query of reporting all integers in <italic>S</italic> contained within a query interval, we present an optimal data structure with linear space cost and with query time linear in the number of integers reported. This result holds in the unit cost RAM model with word size <italic>w</italic> and a standard instruction set. We also present a linear space data structure for approximate range counting. A range counting query for an interval returns the number of integers in <italic>S</italic> contained within the interval. For any constant ε>0, our range counting data structure returns in constant time an approximate answer which is within a factor of at most 1+ε of the correct answer.

A Parallel Priority Queue with Constant Time Operations

We present a parallel priority queue that supports the following operations in constant time:parallel insertionof a sequence of elements ordered according to key,parallel decrease keyfor a sequence of elements ordered according to key,deletion of the minimum key element, anddeletion of an arbitrary element. Our data structure is the first to support multi-insertion and multi-decrease key in constant time. The priority queue can be implemented on the EREW PRAM and can perform any sequence ofnoperations inO(n) time andO(mlogn) work,mbeing the total number of keyes inserted and/or updated. A main application is a parallel implementation of Dijkstras algorithm for the single-source shortest path problem, which runs inO(n) time andO(mlogn) work on a CREW PRAM on graphs withnvertices andmedges. This is a logarithmic factor improvement in the running time compared with previous approaches.

Optimal sparse matrix dense vector multiplication in the I/O-model

We analyze the problem of sparse-matrix dense-vector multiplication (SpMV) in the I/O-model. The task of SpMV is to compute y := Ax, where A is a sparse N x N matrix and x and y are vectors. Here, sparsity is expressed by the parameter k that states that A has a total of at most kN nonzeros, i.e., an average number of k nonzeros per column. The extreme choices for parameter k are well studied special cases, namely for k=1 permuting and for k=N dense matrix-vector multiplication. We study the worst-case complexity of this computational task, i.e., what is the best possible upper bound on the number of I/Os depending on k and N only. We determine this complexity up to a constant factor for large ranges of the parameters. By our arguments, we find that most matrices with kN nonzeros require this number of I/Os, even if the program may depend on the structure of the matrix. The model of computation for the lower bound is a combination of the I/O-models of Aggarwal and Vitter, and of Hong and Kung. We study two variants of the problem, depending on the memory layout of A. If A is stored in column major layout, SpMV has I/O complexity Θ(min{kN B(1+logM/BN max{M,k}), kN}) for k ≤ N1-e and any constant 1> e > 0. If the algorithm can choose the memory layout, the I/O complexity of SpMV is Θ(min{kN B(1+logM/BN kM), kN]) for k ≤ 3√N. In the cache oblivious setting with tall cache assumption M ≥ B1+e, the I/O complexity is Ο(kN B(1+logM/B N k)) for A in column major layout.

Worst-case efficient external-memory priority queues

A priority queue Q is a data structure that maintains a collection of elements, each element having an associated priority drawn from a totally ordered universe, under the operations Insert, which inserts an element into Q, and DeleteMin, which deletes an element with the minimum priority from Q. In this paper a priority-queue implementation is given which is efficient with respect to the number of block transfers or I/Os performed between the internal and external memories of a computer. Let B and M denote the respective capacity of a block and the internal memory measured in elements. The developed data structure handles any intermixed sequence of Insert and DeleteMin operations such that in every disjoint interval of B consecutive priorityqueue operations at most clogM/B N/M I/Os are performed, for some positive constant c. These I/Os are divided evenly among the operations: if B ≥ clogM/B N/M, one I/O is necessary for every B/(clogM/B N/M)th operation and if B < clogM/B N/M, c/B log M/B N/M I/Os are performed per every operation. Moreover, every operation requires O(log2 N) comparisons in the worst case. The best earlier solutions can only handle a sequence of S operations with O(σ i=1 S 1/B log M/B Ni/M) I/Os, where N i denotes the number of elements stored in the data structure prior to the ith operation, without giving any guarantee for the performance of the individual operations.