Previous Deterministic Algorithm Research Articles

Improved deterministic algorithms for non-monotone submodular maximization

Submodular maximization is one of the central topics in combinatorial optimization. It has found numerous applications in the real world. In the past decades, a series of algorithms have been proposed for this problem. However, most of the state-of-the-art algorithms are randomized. There remain non-negligible gaps with respect to approximation ratios between deterministic and randomized algorithms in submodular maximization.In this paper, we propose deterministic algorithms with improved approximation ratios for non-monotone submodular maximization. Specifically, for the matroid constraint, we provide a deterministic 0.283−o(1) approximation algorithm, while the previous best deterministic algorithm only achieves a 1/4 approximation ratio. For the knapsack constraint, we provide a deterministic 1/4 approximation algorithm, while the previous best deterministic algorithm only achieves a 1/6 approximation ratio. For the linear packing constraints with large widths, we provide a deterministic 1/6−ϵ approximation algorithm. To the best of our knowledge, there is currently no deterministic approximation algorithm for the constraints.

An Optimal Deterministic Algorithm for Geodesic Farthest-Point Voronoi Diagrams in Simple Polygons

Given in the plane a set S of m point sites in a simple polygon P of n vertices, we consider the problem of computing the geodesic farthest-point Voronoi diagram for S in P. It is known that the problem has an $$\Omega (n+m\log m)$$ time lower bound. Previously, a randomized algorithm was proposed [Barba, SoCG 2019] that solves the problem in $$O(n+m\log m)$$ expected time. The previous best deterministic algorithms solve the problem in $$O(n\log \log n+ m\log m)$$ time [Oh, Barba, and Ahn, SoCG 2016] or in $$O(n+m\log m+m\log ^2\!n)$$ time [Oh and Ahn, SoCG 2017]. In this paper, we present a deterministic algorithm that takes $$O(n+m\log m)$$ time, which is optimal. This answers affirmatively an open question posed by Mitchell in the Handbook of Computational Geometry two decades ago.

Near-Optimal Algorithms for Shortest Paths in Weighted Unit-Disk Graphs

We revisit a classical graph-theoretic problem, the single-source shortest-path (SSSP) problem, in weighted unit-disk graphs. We first propose an exact (and deterministic) algorithm which solves the problem in \(O(n\log ^2\!n)\) time using linear space, where n is the number of the vertices of the graph. This significantly improves the previous deterministic algorithm by Cabello and Jejčič [CGTA’15] which uses \(O(n^{1+\delta })\) time and \(O(n^{1+\delta })\) space (for any constant \(\delta >0\)) and the previous randomized algorithm by Kaplan et al. [SODA’17] which uses \(O(n\log ^{12+o(1)}\!n)\) expected time and \(O(n\log ^3\!n)\) space. More specifically, we show that if the 2D offline insertion-only (additively) weighted nearest-neighbor problem with k operations (i.e., insertions and queries) can be solved in f(k) time, then the SSSP problem in weighted unit-disk graphs can be solved in \(O(n\log n+f(n))\) time. Using the same framework with some new ideas, we also obtain a \((1+\varepsilon )\)-approximate algorithm for the problem, using \(O(n\log n+n\log ^2(1/\varepsilon ))\) time and linear space. This improves the previous \((1+\varepsilon )\)-approximate algorithm by Chan and Skrepetos [SoCG’18] which uses \(O((1/\varepsilon )^2n\log n)\) time and \(O((1/\varepsilon )^2 n)\) space. More specifically, we show that if the 2D offline insertion-only weighted nearest-neighbor problem with \(k_1\) operations in which at most \(k_2\) operations are insertions can be solved in \(f(k_1,k_2)\) time, then the \((1+\varepsilon )\)-approximate SSSP problem in weighted unit-disk graphs can be solved in \(O(n\log n+f(n,O(\varepsilon ^{-2})))\) time. Because of the \(\Omega (n\log n)\)-time lower bound of the problem (even when approximation is allowed), both of our algorithms are almost optimal.

Deterministic Edge Connectivity in Near-Linear Time

We present a deterministic algorithm that computes the edge-connectivity of a graph in near-linear time. This is for a simple undirected unweighted graph G with n vertices and m edges. This is the first o ( mn ) time deterministic algorithm for the problem. Our algorithm is easily extended to find a concrete minimum edge-cut. In fact, we can construct the classic cactus representation of all minimum cuts in near-linear time. The previous fastest deterministic algorithm by Gabow from STOC '91 took Õ( m +λ 2 n ), where λ is the edge connectivity, but λ can be as big as n −1. Karger presented a randomized near-linear time Monte Carlo algorithm for the minimum cut problem at STOC’96, but the returned cut is only minimum with high probability. Our main technical contribution is a near-linear time algorithm that contracts vertex sets of a simple input graph G with minimum degree Δ, producing a multigraph Ḡ with Õ( m /Δ) edges, which preserves all minimum cuts of G with at least two vertices on each side. In our deterministic near-linear time algorithm, we will decompose the problem via low-conductance cuts found using PageRank a la Brin and Page (1998), as analyzed by Andersson, Chung, and Lang at FOCS’06. Normally, such algorithms for low-conductance cuts are randomized Monte Carlo algorithms, because they rely on guessing a good start vertex. However, in our case, we have so much structure that no guessing is needed.

Randomized Algorithms for Tracking Distributed Count, Frequencies, and Ranks

We show that randomization can lead to significant improvements for a few fundamental problems in distributed tracking. Our basis is the count-tracking problem, where there are k players, each holding a counter $$n_i$$ that gets incremented over time, and the goal is to track an $$\varepsilon $$ -approximation of their sum $$n=\sum _i n_i$$ continuously at all times, using minimum communication. While the deterministic communication complexity of the problem is $${\varTheta }(k/\varepsilon \cdot \log N)$$ , where N is the final value of n when the tracking finishes, we show that with randomization, the communication cost can be reduced to $${\varTheta }(\sqrt{k}/\varepsilon \cdot \log N)$$ . Our algorithm is simple and uses only O(1) space at each player, while the lower bound holds even assuming each player has infinite computing power. Then, we extend our techniques to two related distributed tracking problems: frequency-tracking and rank-tracking, and obtain similar improvements over previous deterministic algorithms. Both problems are of central importance in large data monitoring and analysis, and have been extensively studied in the literature.

A Novel QoS Provisioning Algorithm for Optimal Multicast Routing in WMNs

The problem of optimal multicast routing in Wireless Mess Networks (WMNs) with Quality-of-Service (QoS) provisioning, which is Non-Deterministic Polynomial (NP)-complete, is studied in this paper. The existing algorithms are not very efficient or effective. In order to find an approximation optimal solution for WMNs in feasible time from source to the set of destination nodes, combining the previous deterministic algorithm with the well-known Minimum Path Cost Heuristic (MPH) algorithm, a novel multicast heuristic approximation (NMHA) algorithm with QoS provisioning is proposed in this paper to deal with it. The theoretical validations for the proposed algorithm are presented to show its performance and efficiency. After that, the random static networks with different destination nodes are evaluated. Simulations in these networks show that the proposed algorithm can achieve the approximate optimal solution with the approximation factor of 2(1 + ε)(1 − 1/q) and the time complexity of O(qmn2τK−1).

Optimal Charging of Electric Vehicles using a Stochastic Dynamic Programming Model and Price Prediction

Copyright © 2015 SAE International. The idea of grid friendly charging is to use electricity from the grid to charge batteries when electricity is available in surplus and cheap. The goal is twofold: to avoid putting additional load on the electricity grid and to reduce the cost to the consumer. To achieve this, a smart meter and a tariff with variable electricity prices has to be in place. In Day Ahead tariff (DA), prices are announced in advance for the next day, and this information can be used to select the cheapest times to charge the battery by the required amount. The optimization method is very simple, and it only has to be run once per day. However, the balance of supply and demand is not fully known in advance. Therefore Real Time Pricing (RTP) tariff supplies electricity at spot market rate depending on the current balance. This makes the charging process less predictable because it adds a stochastic element, but it does offer the potential of higher savings if future prices can be predicted with a reasonable degree of accuracy. This paper proposes an optimal controller based on a stochastic dynamic program (SDP), which predicts future price changes from available data. The controller takes into account price variability via a simple grid model that allows of unexpected price rises and a gradual return to a normal grid price. The DP algorithm has two variables, the state of charge (SoC) and the current electricity cost. It traces the expected total cost based on the stochastic model and makes a decision ‘to charge or not’ to minimize the expected (average) total cost. The results show that in case of a positive probability of price rises, the time to charge is chosen slightly before the lowest expected cost during the night. This is a rational solution, because waiting longer does increase the risk of an unexpected price spike. In the trivial case of a zero probability of unexpected price rises, the solution converges to the one found by the previous deterministic optimization algorithm.

How to Meet Asynchronously at Polynomial Cost

Two mobile agents starting at different nodes of an unknown network have to meet. This task is known in the literature as rendezvous. Each agent has a different label which is a positive integer known to it but unknown to the other agent. Agents move in an asynchronous way: the speed of agents may vary and is controlled by an adversary. The cost of a rendezvous algorithm is the total number of edge traversals by both agents until their meeting. The only previous deterministic algorithm solving this problem has cost exponential in the size of the graph and in the larger label. In this paper we present a deterministic rendezvous algorithm with cost polynomial in the size of the graph and in the length of the smaller label. Hence, we decrease the cost exponentially in the size of the graph and doubly exponentially in the labels of agents. As an application of our rendezvous algorithm we solve several fundamental problems involving teams of unknown size larger than 1 of labeled agents moving asynchronously in unknown networks. Among them are the following problems: \tt team size, in which every agent has to find the total number of agents; \tt leader election, in which all agents have to output the label of a single agent; \tt perfect renaming, in which all agents have to adopt new and different labels from the set $\{1,\dots,k\}$, where $k$ is the number of agents; and \tt gossiping, in which each agent has initially a piece of information (value) and all agents have to output all the values. Using our rendezvous algorithm, we solve all of these problems at cost polynomial in the size of the graph and in the smallest length of all labels of participating agents.

Deterministic Sparse Fourier Approximation Via Approximating Arithmetic Progressions

We present a deterministic algorithm for finding the significant Fourier frequencies of a given signal f ∈ C <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">N</sup> and their approximate Fourier coefficients in running time and sample complexity polynomial in log N, L <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1</sub> (f̂)/||f̂|| <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2</sub> , and 1/τ, where the significant frequencies are those occupying at least a τ-fraction of the energy of the signal, and L <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1</sub> (f̂) denotes the L <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">1</sub> -norm of the Fourier transform of f. Furthermore, the algorithm is robust to additive random noise. This strictly extends the class of compressible/Fourier sparse signals efficiently handled by previous deterministic algorithms for signals in C <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">N</sup> . As a central tool, we prove there is a deterministic algorithm that takes as input N, ε and an arithmetic progression P in Z <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">N</sub> , runs in time polynomial in ln N and 1/ε, and returns a set A <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">P</sub> that ε-approximates P in Z <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">N</sub> in the sense that |E <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">x∈A</sub> <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">P</sub> e <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2πiω/N</sup> - E <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">x∈P</sub> e <sup xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">2πiωx/N</sup> | <; ε for all ω = 0,..., N-1. In other words, we show there is an explicit construction of sets A <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">P</sub> of size polynomial in lnN and 1/ε that ε-approximate given arithmetic progressions P in Z <sub xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">N</sub> . This extends results on small-bias sets, which are sets approximating the entire domain, to sets approximating a given arithmetic progression; this result may be of independent interest.

Deterministic Algorithms for the Lovász Local Lemma

The Lovász local lemma (LLL) [P. Erdös and L. Lovász, Problems and results on 3-chromatic hypergraphs and some related questions, in Infinite and Finite Sets, Vol. II, A. Hajnal, R. Rado, and V. T. Sós, eds., North--Holland, Amsterdam, 1975, pp. 609--627] is a powerful result in probability theory that informally states the following: the probability that none of a set of bad events happens is positive if the probability of each event is small compared to the number of events that depend on it. The LLL is often used for nonconstructive existence proofs of combinatorial structures. A prominent application is to $k$-CNF formulas, where the LLL implies that if every clause in a formula shares variables with at most $d \leq 2^k/e-1$ other clauses, then such a formula has a satisfying assignment. Recently, a randomized algorithm to efficiently construct a satisfying assignment in this setting was given by Moser [A constructive proof of the Lovász local lemma, in STOC '09: Proceedings of the 41st Annual ACM Symposium on Theory of Computing, ACM, New York, 2009, pp. 343--350]. Subsequently Moser and Tardos [J. ACM, 57 (2010), pp. 11:1--11:15] gave a general algorithmic framework for the LLL and a randomized algorithm within this framework to construct the structures guaranteed by the LLL. The main problem left open by Moser and Tardos was to design an efficient deterministic algorithm for constructing structures guaranteed by the LLL. In this paper we provide such an algorithm. Our algorithm works in the general framework of Moser and Tardos with a minimal loss in parameters. For the special case of constructing satisfying assignments for $k$-CNF formulas with $m$ clauses, where each clause shares variables with at most $d \leq 2^{k/(1+\epsilon)}/e - 1$ other clauses, for any $\epsilon\in (0,1)$, we give a deterministic algorithm that finds a satisfying assignment in time $\tilde{O}(m^{2(1+1/\epsilon)})$. This improves upon the deterministic algorithms of Moser and of Moser and Tardos with running times $m^{\Omega(k^2)}$ and $m^{\Omega(d \log d)}$, respectively, which are superpolynomial for $k=\omega(1)$ and $d=\omega(1)$, and upon the previous best deterministic algorithm of Beck, which runs in polynomial time only for $d\leq 2^{k/16}/4$. Our algorithm is the first deterministic algorithm that works in the general framework of Moser and Tardos. We also give a parallel NC algorithm for the same setting, improving upon an algorithm of Alon [Random Structures Algorithms, 2 (1991), pp. 367--378].

ADAPTIVE SUB-LINEAR TIME FOURIER ALGORITHMS

We present a new deterministic algorithm for the sparse Fourier transform problem, in which we seek to identify k ≪ N significant Fourier coefficients from a signal of bandwidth N. Previous deterministic algorithms exhibit quadratic runtime scaling, while our algorithm scales linearly with k in the average case. Underlying our algorithm are a few simple observations relating the Fourier coefficients of time-shifted samples to unshifted samples of the input function. This allows us to detect when aliasing between two or more frequencies has occurred, as well as to determine the value of unaliased frequencies. We show that empirically our algorithm is orders of magnitude faster than competing algorithms.

Running Max/Min Filters Using 1+o(1) Comparisons per Sample

A running max (or min) filter asks for the maximum or (minimum) elements within a fixed-length sliding window. The previous best deterministic algorithm (developed by Gil and Kimmel, and refined by Coltuc) can compute the 1D max filter using 1.5+o(1) comparisons per sample in the worst case. The best known algorithm for independent and identically distributed input uses 1.25+o(1) expected comparisons per sample(by Gil and Kimmel). In this work, we show that the number of comparisons can be reduced to 1+o(1) comparisons per sample in the worst case. As a consequence of the new max/min filters, the opening (or closing) filter can also be computed using 1+o(1) comparisons per sample in the worst case, where the previous best work requires 1.5+o(1) comparisons per sample (by Gil and Kimmel); and computing the max and min filters simultaneously can be done in 2+o(1) comparisons per sample in the worst case, where the previous best work (by Lemire) requires 3 comparisons per sample. Our improvements over the previous work are asymptotic, that is, the number of comparisons is reduced only when the window size is large.

Improved Parameterized Set Splitting Algorithms: A Probabilistic Approach

In this paper, we study parameterized algorithms for the set splitting problem, for both weighted and unweighted versions. First, we develop a new and effective technique based on a probabilistic method that allows us to develop a simpler and more efficient deterministic kernelization algorithm for the unweighted set splitting problem. We then propose a randomized algorithm for the weighted set splitting problem that is based on a new subset partition technique and has its running time bounded by O *(2 k ), which is significantly better than that of the previous best deterministic algorithm (which only works for the simpler unweighted set splitting problem) of running time O *(2.65 k ). We also show that our algorithm can be de-randomized, which leads to a deterministic parameterized algorithm of running time O *(4 k ) for the weighted set splitting problem and gives the first proof that the problem is fixed-parameter tractable.

Fast deterministic distributed algorithms for sparse spanners

This paper concerns the efficient construction of sparse and low stretch spanners for unweighted arbitrary graphs with n nodes. All previous deterministic distributed algorithms, for constant stretch spanners of o ( n 2 ) edges, have a running time Ω ( n ϵ ) for some constant ϵ > 0 depending on the stretch. Our deterministic distributed algorithms construct constant stretch spanners of o ( n 2 ) edges in o ( n ϵ ) time for any constant ϵ > 0 . More precisely, in Linial’s free model a.k.a L O C A L model, we construct in n O ( 1 / log n ) time, for every graph, a ( 3 , 2 ) -spanner of O ( n 3 / 2 ) edges, i.e., a spanning subgraph in which the distance is at most 3 times the distance of the original graph plus 2. The result is extended to ( α k , β k ) -spanners with O ( n 1 + 1 / k log k ) edges for every integer parameter k ≥ 1 , where α k + β k = O ( k log 2 5 ) . If the minimum degree of the graph is Ω ( n ) , then, in the same time complexity, a ( 5 , 4 ) -spanner with O ( n ) edges can be constructed.

Deterministic algorithms for sampling count data

Processing and extracting meaningful knowledge from count data is an important problem in data mining. The volume of data is increasing dramatically as the data is generated by day-to-day activities such as market basket data, web clickstream data or network data. Most mining and analysis algorithms require multiple passes over the data, which requires extreme amounts of time. One solution to save time would be to use samples, since sampling is a good surrogate for the data and the same sample can be used to answer many kinds of queries. In this paper, we propose two deterministic sampling algorithms, Biased-L2 and DRS. Both produce samples vastly superior to the previous deterministic and random algorithms, both in sample quality and accuracy. Our algorithms also improve on the run-time and memory footprint of the existing deterministic algorithms. The new algorithms can be used to sample from a relational database as well as data streams, with the ability to examine each transaction only once, and maintain the sample on-the-fly in a streaming fashion. We further show how to engineer one of our algorithms (DRS) to adapt and recover from changes to the underlying data distribution, or sample size. We evaluate our algorithms on three different synthetic datasets, as well as on real-world clickstream data, and demonstrate the improvements over previous art.

Fast and scalable algorithms for the Euclidean distance transform on a linear array with a reconfigurable pipelined bus system

The Euclidean distance transform ( EDT) is an operation to convert a binary image consisting of black and white pixels to a representation where each pixel has the Euclidean distance of the nearest black pixel. The EDT has many applications in computer vision and image processing. We present two algorithms for computing the EDT on the linear array with a reconfigurable pipelined bus system (LARPBS), a recently proposed architecture based on optical buses. Our first algorithm runs in O( log log N) time for a binary N× N image on an LARPBS with N 2+ ε processors, for any fixed ε, 0< ε<1. Our second algorithm is highly scalable and runs in O( N 2 p 2 log log p) time if the LARPBS has only p 2+ ε processors for p< N. The previous best deterministic algorithm for computing the EDT on the LARPBS is by Pan et al. Proceedings of IPDPS 2000 Workshop on Parallel and Distributed Computing in Image Processing, Video Processing and Multimedia (PDIVM 2000), Lecture Notes in Computer Science, Vol. 1800, Springer, Berlin, 178). Their algorithm runs either in O( log N log log N) time on an LARPBS with N 2 processors or in O( log log N) time on an LARPBS with O( N 3) processors.

Deterministic approximation of the cover time

AbstractThe cover time is the expected time it takes a random walk to cover all vertices of a graph. Despite the fact that it can be approximated with arbitrary precision by a simple polynomial time Monte‐Carlo algorithm which simulates the random walk, it is not known whether the cover time of a graph can be computed in deterministic polynomial time. In the present paper we establish a deterministic polynomial time algorithm that, for any graph and any starting vertex, approximates the cover time within polylogarithmic factors. More generally, our algorithm approximates the cover time for arbitrary reversible Markov chains. The new aspect of our algorithm is that the starting vertex of the random walk may be arbitrary and is given as part of the input, whereas previous deterministic approximation algorithms for the cover time assume that the walk starts at the worst possible vertex. In passing, we show that the starting vertex can make a difference of up to a multiplicative factor of $\Theta(n^{3/2}/\sqrt{\log\, n})$ in the cover time of an n‐vertex graph. © 2003 Wiley Periodicals, Inc. Random Struct. Alg., 23: 1–22, 2003

Deterministic Dictionaries

It is shown that a static dictionary that offers constant-time access to n elements with w-bit keys and occupies O(n) words of memory can be constructed deterministically in O(nlogn) time on a unit-cost RAM with word length w and a standard instruction set including multiplication. Whereas a randomized construction working in linear expected time was known, the running time of the best previous deterministic algorithm was Ω(n2). Using a standard dynamization technique, the first deterministic dynamic dictionary with constant lookup time and sublinear update time is derived. The new algorithms are weakly nonuniform; i.e., they require access to a fixed number of precomputed constants dependent on w. The main technical tools employed are unit-cost error-correcting codes, word parallelism, and derandomization using conditional expectations.

An Optimal Deterministic Algorithm for Computing the Diameter of a Three-Dimensional Point Set

We describe a deterministic algorithm for computing the diameter of a finite set of points in R 3 , that is, the maximum distance between any pair of points in the set. The algorithm runs in optimal time O(nlog n) for a set of n points. The first optimal, but randomized, algorithm for this problem was proposed more than 10 years ago by Clarkson and Shor [11] in their ground-breaking paper on geometric applications of random sampling. Our algorithm is relatively simple except for a procedure by Matoušek [25] for the efficient deterministic construction of epsilon-nets. This work improves previous deterministic algorithms by Ramos [31] and Bespamyatnikh [7], both with running time O(nlog 2 n) . The diameter algorithm appears to be the last one in Clarkson and Shor’s paper that up to now had no deterministic counterpart with a matching running time.

Fast deterministic selection on mesh-connected processor arrays

We present a deterministic algorithm for selecting the element of rankk amongN=n2 elements, 1≤k≤N, on ann×n mesh-connected processor array in 1.45n parallel computation steps, using constant-sized queues (for large enoughn). This is a considerable improvement over the best previous deterministic algorithm, which was based upon sorting and requires2n+o(n) steps. Our algorithm can be generalized to solve the problem of selection on higher-dimensional meshes. In particular, we present an algorithm for the three-dimensional mesh which achieves a time bound better than any of the previously known deterministic results.