Subquadratic Time Research Articles

PROMETHEE is not quadratic: An [formula omitted] algorithm

It is generally believed that the preference ranking method PROMETHEE has a quadratic time complexity. In this paper, however, we present an exact algorithm that computes PROMETHEE’s net flow scores in time O(qnlog(n)), where q represents the number of criteria and n the number of alternatives. The method is based on first sorting the alternatives after which the unicriterion flow scores of all alternatives can be computed in one scan over the sorted list of alternatives while maintaining a sliding window. This method works with the linear and level criterion preference functions. The algorithm we present is exact and, due to the sub-quadratic time complexity, vastly extends the applicability of the PROMETHEE method. Experiments show that with the new algorithm, PROMETHEE can scale up to millions of tuples.

QRE: Quick Robustness Estimation for large complex networks

Robustness estimation is critical for the design and maintenance of resilient networks. Existing studies on network robustness usually exploit a single network metric to generate attack strategies, which simulate intentional attacks on a network, and compute a metric-induced robustness estimation, called R. While some metrics are easy to compute, e.g. degree, others require considerable computation efforts, e.g. betweenness centrality. We propose Quick Robustness Estimation (QRE), a new framework and implementation for estimating the robustness of a network in sub-quadratic time, i.e., significantly faster than betweenness centrality, based on the combination of cheap-to-compute network metrics. Experiments on twelve real-world networks show that QRE estimates the robustness better than betweenness centrality-based computation, while being at least one order of magnitude faster for larger networks. Our work contributes towards scalable, yet accurate robustness estimation for large complex networks.

Robust cell tracking in epithelial tissues through identification of maximum common subgraphs.

Tracking of cells in live-imaging microscopy videos of epithelial sheets is a powerful tool for investigating fundamental processes in embryonic development. Characterizing cell growth, proliferation, intercalation and apoptosis in epithelia helps us to understand how morphogenetic processes such as tissue invagination and extension are locally regulated and controlled. Accurate cell tracking requires correctly resolving cells entering or leaving the field of view between frames, cell neighbour exchanges, cell removals and cell divisions. However, current tracking methods for epithelial sheets are not robust to large morphogenetic deformations and require significant manual interventions. Here, we present a novel algorithm for epithelial cell tracking, exploiting the graph-theoretic concept of a ‘maximum common subgraph’ to track cells between frames of a video. Our algorithm does not require the adjustment of tissue-specific parameters, and scales in sub-quadratic time with tissue size. It does not rely on precise positional information, permitting large cell movements between frames and enabling tracking in datasets acquired at low temporal resolution due to experimental constraints such as phototoxicity. To demonstrate the method, we perform tracking on the Drosophila embryonic epidermis and compare cell–cell rearrangements to previous studies in other tissues. Our implementation is open source and generally applicable to epithelial tissues.

IP Fast Rerouting for Multi-Link Failures

IP fast reroute methods are used to recover packets in the data plane upon link failures. Previous work provided methods that guarantee failure recovery from at most two-link failures. We develop an IP fast reroute method that employs rooted arc-disjoint spanning trees to guarantee recovery from up to $(k-1)$ link failures in a $k$ -edge-connected network. As arc-disjoint spanning trees may be constructed in sub-quadratic time in the size of the network, our approach offers excellent scalability. Through experimental results, we show that employing arc-disjoint spanning trees to recover from multiple failures reduces path stretch in comparison with previously known techniques.

Visual analytics of delays and interaction in movement data

ABSTRACTThe analysis of interaction between movement trajectories is of interest for various domains when movement of multiple objects is concerned. Interaction often includes a delayed response, making it difficult to detect interaction with current methods that compare movement at specific time intervals. We propose analyses and visualizations, on a local and global scale, of delayed movement responses, where an action is followed by a reaction over time, on trajectories recorded simultaneously. We developed a novel approach to compute the global delay in subquadratic time using a fast Fourier transform (FFT). Central to our local analysis of delays is the computation of a matching between the trajectories in a so-called delay space. It encodes the similarities between all pairs of points of the trajectories. In the visualization, the edges of the matching are bundled into patches, such that shape and color of a patch help to encode changes in an interaction pattern. To evaluate our approach experimentally, we have implemented it as a prototype visual analytics tool and have applied the tool on three bidimensional data sets. For this we used various measures to compute the delay space, including the directional distance, a new similarity measure, which captures more complex interactions by combining directional and spatial characteristics. We compare matchings of various methods computing similarity between trajectories. We also compare various procedures to compute the matching in the delay space, specifically the Fréchet distance, dynamic time warping (DTW), and edit distance (ED). Finally, we demonstrate how to validate the consistency of pairwise matchings by computing matchings between more than two trajectories.

Towards sub-quadratic time and space complexity solutions for the dated tree reconciliation problem.

BackgroundRecent coevolutionary analysis has considered tree topology as a means to reduce the asymptotic complexity associated with inferring the complex coevolutionary interrelationships that arise between phylogenetic trees. Targeted algorithmic design for specific tree topologies has to date been highly successful, with one recent formulation providing a logarithmic space complexity reduction for the dated tree reconciliation problem.MethodsIn this work we build on this prior analysis providing a further asymptotic space reduction, by providing a new formulation for the dynamic programming table used by a number of popular coevolutionary analysis techniques. This model gives rise to a sub quadratic running time solution for the dated tree reconciliation problem for selected tree topologies, and is shown to be, in practice, the fastest method for solving the dated tree reconciliation problem for expected evolutionary trees. This result is achieved through the analysis of not only the topology of the trees considered for coevolutionary analysis, but also the underlying structure of the dynamic programming algorithms that are traditionally applied to such analysis.ConclusionThe newly inferred theoretical complexity bounds introduced herein are then validated using a combination of synthetic and biological data sets, where the proposed model is shown to provide an O(sqrt{n}) space saving, while it is observed to run in half the time compared to the fastest known algorithm for solving the dated tree reconciliation problem. What is even more significant is that the algorithm derived herein is able to guarantee the optimality of its inferred solution, something that algorithms of comparable speed have to date been unable to achieve.

Analytical Clustering Score with Application to Postplacement Register Clustering

Circuit clustering is usually done through discrete optimizations to enable circuit size reduction or design-specific cluster formation. In this article, we are interested in the register-clustering technique for clock-power reduction by leveraging new opportunities introduced by multibit flip-flop (MBFF). Currently, INTEGRA is the only existing postplacement MBFF clustering optimizer with a subquadratic time complexity. However, it severely degrades the wirelength, especially for realistic designs, which may nullify the benefits of MBFF clustering. In contrast, we formulate an analytical clustering score with a nonlinear programming framework, in which the wirelength objective can be seamlessly integrated and the solver has empirical subquadratic time complexity. With the MBFF library, the application of our analytical clustering method achieves comparable clock power to the state-of-the-art techniques, but further reduces the wirelength by about 25%. Even without the MBFF library, we can still achieve 30% clock wirelength reduction. In addition, the proposed method can potentially be integrated into an in-placement MBFF clustering solver and be applied to other problems that require formulating clustering scores in their objective functions.

Distribution-Sensitive Construction of the Greedy Spanner

The greedy spanner is the highest quality geometric spanner (in e.g. edge count and weight, both in theory and practice) known to be computable in polynomial time. Unfortunately, all known algorithms for computing it on n points take varOmega (n^2) time, limiting its applicability on large data sets. We propose a novel algorithm design which uses the observation that for many point sets, the greedy spanner has many ‘short’ edges that can be determined locally and usually quickly. To find the usually few remaining ‘long’ edges, we use a combination of already determined local information and the well-separated pair decomposition. We give experimental results showing large to massive performance increases over the state-of-the-art on nearly all tests and real-life data sets. On the theoretical side we prove a near-linear expected time bound on uniform point sets and a near-quadratic worst-case bound. Our bound for point sets drawn uniformly and independently at random in a square follows from a local characterization of t-spanners we give on such point sets. We give a geometric property that holds with high probability, which in turn implies that if an edge set on these points has t-paths between pairs of points ‘close’ to each other, then it has t-paths between all pairs of points. This characterization gives an O(n log ^2 n log ^2 log n) expected time bound on our greedy spanner algorithm, making it the first subquadratic time algorithm for this problem on any interesting class of points. We also use this characterization to give an O((n + |E|) log ^2 n log log n) expected time algorithm on uniformly distributed points that determines whether E is a t-spanner, making it the first subquadratic time algorithm for this problem that does not make assumptions on E.

Into the Square: On the Complexity of Some Quadratic-time Solvable Problems

We analyze several quadratic-time solvable problems, and we show that these problems are not solvable in truly subquadratic time (that is, in time O(n2−ϵ) for some ϵ>0), unless the well known Strong Exponential Time Hypothesis (in short, SETH) is false. In particular, we start from an artificial quadratic-time solvable variation of the k-Sat problem (already introduced and used in the literature) and we will construct a web of Karp reductions, proving that a truly subquadratic-time algorithm for any of the problems in the web falsifies SETH. Some of these results were already known, while others are, as far as we know, new. The new problems considered are: computing the betweenness centrality of a vertex (the same result was proved independently by Abboud et al.), computing the minimum closeness centrality in a graph, computing the hyperbolicity of a graph, and computing the subset graph of a collection of sets. On the other hand, we will show that testing if a directed graph is transitive and testing if a graph is a comparability graph are subquadratic-time solvable (our algorithm is practical, since it is not based on intricate matrix multiplication algorithms).

Detecting the large entries of a sparse covariance matrix in sub-quadratic time

The covariance matrix of a $p$-dimensional random variable is a fundamental quantity in data analysis. Given $n$ i.i.d. observations, it is typically estimated by the sample covariance matrix, at a computational cost of $O(np^{2})$ operations. When $n,p$ are large, this computation may be prohibitively slow. Moreover, in several contemporary applications, the population matrix is approximately sparse, and only its few large entries are of interest. This raises the following question, at the focus of our work: Assuming approximate sparsity of the covariance matrix, can its large entries be detected much faster, say in sub-quadratic time, without explicitly computing all its $p^{2}$ entries? In this paper, we present and theoretically analyze two randomized algorithms that detect the large entries of an approximately sparse sample covariance matrix using only $O(np\text{ poly log } p)$ operations. Furthermore, assuming sparsity of the population matrix, we derive sufficient conditions on the underlying random variable and on the number of samples $n$, for the sample covariance matrix to satisfy our approximate sparsity requirements. Finally, we illustrate the performance of our algorithms via several simulations.

Decoding Hidden Markov Models Faster Than Viterbi Via Online Matrix-Vector (max, +)-Multiplication

In this paper, we present a novel algorithm for the maximum a posteriori decoding (MAPD) of time-homogeneous Hidden Markov Models (HMM), improving the worst-case running time of the classical Viterbi algorithm by a logarithmic factor. In our approach, we interpret the Viterbi algorithm as a repeated computation of matrix-vector (max, +)-multiplications. On time-homogeneous HMMs, this computation is online: a matrix, known in advance, has to be multiplied with several vectors revealed one at a time. Our main contribution is an algorithm solving this version of matrix-vector (max,+)-multiplication in subquadratic time, by performing a polynomial preprocessing of the matrix. Employing this fast multiplication algorithm, we solve the MAPD problem in O(mn2/log n) time for any time-homogeneous HMM of size n and observation sequence of length m, with an extra polynomial preprocessing cost negligible for m > n. To the best of our knowledge, this is the first algorithm for the MAPD problem requiring subquadratic time per observation, under the assumption — usually verified in practice — that the transition probability matrix does not change with time.

Shortest path in a polygon using sublinear space

We resolve an open problem due to Tetsuo Asano, showing how to compute the shortest path in a polygon, given in a read only memory, using sublinear space and subquadratic time. Specifically, given a simple polygon $P$ with $n$ vertices in a read only memory, and additional working memory of size $m$, the new algorithm computes the shortest path (in $P$) in $O( n^2 / m )$ expected time, assuming $m = O(n/\log^2 n)$. This requires several new tools, which we believe to be of independent interest. Specifically, we show that violator space problems, an abstraction of low dimensional linear-programming (and LP-type problems), can be solved using constant space and expected linear time, by modifying Seidel's linear programming algorithm and using pseudo-random sequences.

Approximability of the discrete Fréchet distance

The Frechet distance is a popular and widespread distance measure for point sequences and for curves. About two years ago, Agarwal et al. [SIAM J. Comput. 2014] presented a new (mildly) subquadratic algorithm for the discrete version of the problem. This spawned a flurry of activity that has led to several new algorithms and lower bounds. In this paper, we study the approximability of the discrete Frechet distance. Building on a recent result by Bringmann [FOCS 2014], we present a new conditional lower bound showing that strongly subquadratic algorithms for the discrete Frechet distance are unlikely to exist, even in the one-dimensional case and even if the solution may be approximated up to a factor of 1.399. This raises the question of how well we can approximate the Frechet distance (of two given $d$-dimensional point sequences of length $n$) in strongly subquadratic time. Previously, no general results were known. We present the first such algorithm by analysing the approximation ratio of a simple, linear-time greedy algorithm to be $2^{\Theta(n)}$. Moreover, we design an $\alpha$-approximation algorithm that runs in time $O(n\log n + n^2/\alpha)$, for any $\alpha\in [1, n]$. Hence, an $n^\varepsilon$-approximation of the Frechet distance can be computed in strongly subquadratic time, for any $\varepsilon > 0$.

Computing force field-based directional maps in subquadratic time

Spatial knowledge, i.e., knowledge about configurations among distinct spatial entities, plays a key role in everyday life and has wide applications in numerous application domains. In particular, computer vision systems exploit spatial knowledge to enhance their object recognition capabilities. The focus of this article is on the representation of spatial knowledge. Specifically, we concentrate on the representation of spatial relationships among objects in an image, a fundamental problem in pattern recognition and computer vision. In the study of spatial relationships, significant progress has been made by using directional maps. However, the time complexity of map generation is O(N2) and thus not practical. We present an improvement of a state-of-the-art approximation method that is based on an analogy with the force exerted by an object on another object. The improvement is based on the use of a family of forces whose dependence on the pixel–pixel distance r is of the type 1/rl+1 with l > 1. Analysis of time complexity shows that the improved method is O(Nx), with x=1+3/(l+2). Application of this method to both artificial and real images validates the time complexity analysis and shows that the proposed method is much faster than the original method. Furthermore, for the special case of small objects relative to the image size, the proposed method generates more accurate maps and, in other cases, the difference in accuracy is very small.

Finding Correlations in Subquadratic Time, with Applications to Learning Parities and the Closest Pair Problem

Given a set of n d -dimensional Boolean vectors with the promise that the vectors are chosen uniformly at random with the exception of two vectors that have Pearson correlation coefficient ρ (Hamming distance d · 1-ρ/ 2), how quickly can one find the two correlated vectors? We present an algorithm which, for any constant ϵ>0, and constant ρ>0, runs in expected time O (n 5-ω / 4-ω+ϵ +nd) < O (n 1.62 +nd), where ω < 2.4 is the exponent of matrix multiplication. This is the first subquadratic--time algorithm for this problem for which ρ does not appear in the exponent of n , and improves upon O (n 2-O(ρ) ), given by Paturi et al. [1989], the Locality Sensitive Hashing approach of Motwani [1998] and the Bucketing Codes approach of Dubiner [2008]. Applications and extensions of this basic algorithm yield significantly improved algorithms for several other problems. Approximate Closest Pair. For any sufficiently small constant ϵ>0, given n d -dimensional vectors, there exists an algorithm that returns a pair of vectors whose Euclidean (or Hamming) distance differs from that of the closest pair by a factor of at most 1+ϵ, and runs in time O (n 2-Θ(√ϵ )). The best previous algorithms (including Locality Sensitive Hashing) have runtime O (n 2-O(ϵ) ). Learning Sparse Parities with Noise. Given samples from an instance of the learning parities with noise problem where each example has length n , the true parity set has size at most k « n , and the noise rate is η, there exists an algorithm that identifies the set of k indices in time n ω+ϵ/3 k poly(1/1-2η) < n 0.8k poly(1/1-2 η). This is the first algorithm with no dependence on η in the exponent of n , aside from the trivial O (( n k )) ≈ O ( n k ) brute-force algorithm, and for large noise rates (η > 0.4), improves upon the results of Grigorescu et al. [2011] that give a runtime of n (1+(2 η) 2 + o (1))k/2 poly (1/1-2η). Learning k -Juntas with Noise. Given uniformly random length n Boolean vectors, together with a label, which is some function of just k « n of the bits, perturbed by noise rate η, return the set of relevant indices. Leveraging the reduction of Feldman et al. [2009], our result for learning k -parities implies an algorithm for this problem with runtime n ω+ϵ/3 k poly (1/1-2η) < n 0.8k poly (1/1-2 η), which is the first runtime for this problem of the form n ck with an absolute constant c < 1. Learning k -Juntas without Noise. Given uniformly random length n Boolean vectors, together with a label, which is some function of k « n of the bits, return the set of relevant indices. Using a modification of the algorithm of Mossel et al. [2004], and employing our algorithm for learning sparse parities with noise via the reduction of Feldman et al. [2009], we obtain an algorithm for this problem with runtime n ω+ ϵ/4 k poly(n) < n 0.6k poly(n) , which improves on the previous best of n ω+1/ωk ≈ n 0.7k poly(n) of Mossel et al. [2004].

A note on the longest common substring with k-mismatches problem

The recently introduced longest common substring with k-mismatches (k-LCF) problem is to find, given two sequences S1 and S2 of length n each, a longest substring A1 of S1 and A2 of S2 such that the Hamming distance between A1 and A2 is at most k. So far, the only subquadratic time result for this problem was known for k=1[5]. We present two output-dependent algorithms solving the k-LCF problem and show that for k=O(log1−ε⁡n), where ε>0, at least one of them works in subquadratic time, using O(n) words of space. The choice of one of these two algorithms to be applied for a given input can be done after linear time and space preprocessing.

Min st -Cut Oracle for Planar Graphs with Near-Linear Preprocessing Time

For an undirected n -vertex planar graph G with nonnegative edge weights, we consider the following type of query: given two vertices s and t in G , what is the weight of a min st -cut in G ? We show how to answer such queries in constant time with O ( n log 4 n ) preprocessing time and O ( n log n ) space. We use a Gomory-Hu tree to represent all the pairwise min cuts implicitly. Previously, no subquadratic time algorithm was known for this problem. Since all-pairs min cut and the minimum-cycle basis are dual problems in planar graphs, we also obtain an implicit representation of a minimum-cycle basis in O ( n log 4 n ) time and O ( n log n ) space. Additionally, an explicit representation can be obtained in O ( C ) time and space where C is the size of the basis. These results require that shortest paths are unique. This can be guaranteed either by using randomization without overhead or deterministically with an additional log 2 n factor in the preprocessing times.

Canonical Labelling of Site Graphs

We investigate algorithms for canonical labelling of site graphs, i.e. graphs in which edges bind vertices on sites with locally unique names. We first show that the problem of canonical labelling of site graphs reduces to the problem of canonical labelling of graphs with edge colourings. We then present two canonical labelling algorithms based on edge enumeration, and a third based on an extension of Hopcroft's partition refinement algorithm. All run in quadratic worst case time individually. However, one of the edge enumeration algorithms runs in sub-quadratic time for graphs with "many" automorphisms, and the partition refinement algorithm runs in sub-quadratic time for graphs with "few" bisimulation equivalences. This suite of algorithms was chosen based on the expectation that graphs fall in one of those two categories. If that is the case, a combined algorithm runs in sub-quadratic worst case time. Whether this expectation is reasonable remains an interesting open problem.

Approximating the maximum consecutive subsums of a sequence

We present a novel approach for computing all maximum consecutive subsums in a sequence of positive integers in near-linear time. Solutions for this problem over binary sequences can be used for reporting existence of Parikh vectors in a bit string. Recently, several attempts have been made to build indexes for all Parikh vectors of a binary string in subquadratic time. However, no algorithm is known to date which can beat by more than a polylogarithmic factor the naive Θ(n2) procedure. We show how to construct a (1+ϵ)-approximate index for all Parikh vectors of a binary string in O(nlog2nlog(1+ϵ)) time, for any constant ϵ>0. Such index is approximate, in the sense that it leaves a small chance for false positives (no false negatives are possible). However, we can tune the parameters of the algorithm so that we can strictly control such a chance of error while still guaranteeing strong subquadratic running time.

New Algorithms for Facility Location Problems on the Real Line

In this paper, we study the facility location problems on the real line. Given a set of n customers on the real line, each customer having a cost for setting up a facility at its position, and an integer k, we seek to find at most k of the customers to set up facilities for serving all n customers such that the total cost for facility set-up and service transportation is minimized. We consider several problem variations including the k-median, the k-coverage, and the linear model. The previously best algorithms for these problems all take O(nk) time. Our new algorithms break the O(nk) time bottleneck and solve these problems in sub-quadratic time. Our algorithms are based on a new problem modeling and interesting algorithmic techniques, which may find other applications as well.