Results 1  10
of
75
Subcubic Equivalences Between Path, Matrix, and Triangle Problems
"... We say an algorithm on n × n matrices with entries in [−M,M] (or nnode graphs with edge weights from [−M,M]) is truly subcubic if it runs in O(n 3−δ · poly(log M)) time for some δ> 0. We define a notion of subcubic reducibility, and show that many important problems on graphs and matrices solvab ..."
Abstract

Cited by 42 (11 self)
 Add to MetaCart
(Show Context)
We say an algorithm on n × n matrices with entries in [−M,M] (or nnode graphs with edge weights from [−M,M]) is truly subcubic if it runs in O(n 3−δ · poly(log M)) time for some δ> 0. We define a notion of subcubic reducibility, and show that many important problems on graphs and matrices solvable in O(n 3) time are equivalent under subcubic reductions. Namely, the following weighted problems either all have truly subcubic algorithms, or none of them do: • The allpairs shortest paths problem on weighted digraphs (APSP). • Detecting if a weighted graph has a triangle of negative total edge weight. • Listing up to n 2.99 negative triangles in an edgeweighted graph. • Finding a minimum weight cycle in a graph of nonnegative edge weights. • The replacement paths problem on weighted digraphs. • Finding the second shortest simple path between two nodes in a weighted digraph. • Checking whether a given matrix defines a metric. • Verifying the correctness of a matrix product over the (min,+)semiring. Therefore, if APSP cannot be solved in n 3−ε time for any ε> 0, then many other problems also
Speeding Up HMM Decoding and Training by Exploiting Sequence Repetitions
"... We present a method to speed up the dynamic program algorithms used for solving the HMM decoding and training problems for discrete timeindependent HMMs. We discuss the application of our method to Viterbi’s decoding and training algorithms [33], as well as to the forwardbackward and BaumWelch [ ..."
Abstract

Cited by 22 (6 self)
 Add to MetaCart
(Show Context)
We present a method to speed up the dynamic program algorithms used for solving the HMM decoding and training problems for discrete timeindependent HMMs. We discuss the application of our method to Viterbi’s decoding and training algorithms [33], as well as to the forwardbackward and BaumWelch [6] algorithms. Our approach is based on identifying repeated substrings in the observed input sequence. Initially, we show how to exploit repetitions of all sufficiently small substrings (this is similar to the Four Russians method). Then, we describe four algorithms based alternatively on run length encoding (RLE), LempelZiv (LZ78) parsing, grammarbased compression (SLP), and byte pair encoding (BPE). Compared to Viterbi’s algorithm, we achieve speedups of Θ(log n) using the Four Russians method, Ω ( r log n r) using RLE, Ω ( ) using LZ78, Ω ( ) using SLP, and Ω(r) using BPE, where k is the number log r k k of hidden states, n is the length of the observed sequence and r is its compression ratio (under each compression scheme). Our experimental results demonstrate that our new algorithms are indeed faster in practice. Furthermore, unlike Viterbi’s algorithm, our algorithms are highly parallelizable.
Regularity lemmas and combinatorial algorithms
 In Proc. FOCS
"... Abstract — We present new combinatorial algorithms for Boolean matrix multiplication (BMM) and preprocessing a graph to answer independent set queries. We give the first asymptotic improvements on combinatorial algorithms for dense BMM in many years, improving on the “Four Russians ” O(n 3 /(w log n ..."
Abstract

Cited by 19 (3 self)
 Add to MetaCart
(Show Context)
Abstract — We present new combinatorial algorithms for Boolean matrix multiplication (BMM) and preprocessing a graph to answer independent set queries. We give the first asymptotic improvements on combinatorial algorithms for dense BMM in many years, improving on the “Four Russians ” O(n 3 /(w log n)) bound for machine models with wordsize w. (For a pointer machine, we can set w = log n.) The algorithms utilize notions from Regularity Lemmas for graphs in a novel way. • We give two randomized combinatorial algorithms for BMM. The first algorithm is essentially a reduction from BMM to the Triangle Removal Lemma. The best known bounds for the Triangle Removal Lemma only imply an O ` (n 3 log β)/(βw log n) ´ time algorithm for BMM where β = (log ∗ n) δ for some δ> 0, but improvements on the Triangle Removal Lemma would yield corresponding runtime improvements. The second algorithm applies the Weak Regularity Lemma of Frieze and Kannan along with “ several information compression ideas, running in O n 3 (log log n) 2 /(log n) 9/4 ”) time with probability exponentially “ close to 1. When w ≥ log n, it can be implemented in O n 3 (log log n) 2 /(w log n) 7/6 ”) time. Our results immediately imply improved combinatorial methods for CFG parsing, detecting trianglefreeness, and transitive closure. Using Weak Regularity, we also give an algorithm for answering queries of the form is S ⊆ V an independent set? in a graph. Improving on prior work, we show how to randomly preprocess a graph in O(n 2+ε) time (for all ε> 0) so that with high probability, all subsequent batches of log n independent “ set queries can be answered deterministically in O n 2 (log log n) 2 /((log n) 5/4 ”) time. When w ≥ log n, w queries can be answered in O n 2 (log log n) 2 /((log n) 7/6 ” time. In addition to its nice applications, this problem is interesting in that it is not known how to do better than O(n 2) using “algebraic ” methods. 1.
Counting Inversions, Offline Orthogonal Range Counting, and Related Problems
"... We give an O(n √ lg n)time algorithm for counting the number of inversions in a permutation on n elements. This improves a longstanding previous bound of O(n lg n / lg lg n) that followed from Dietz’s data structure [WADS’89], and answers a question of Andersson and Petersson [SODA’95]. As Dietz’s ..."
Abstract

Cited by 16 (4 self)
 Add to MetaCart
We give an O(n √ lg n)time algorithm for counting the number of inversions in a permutation on n elements. This improves a longstanding previous bound of O(n lg n / lg lg n) that followed from Dietz’s data structure [WADS’89], and answers a question of Andersson and Petersson [SODA’95]. As Dietz’s result is known to be optimal for the related dynamic rank problem, our result demonstrates a significant improvement in the offline setting. Our new technique is quite simple: we perform a “vertical partitioning ” of a trie (akin to van Emde Boas trees), and use ideas from external memory. However, the technique finds numerous applications: for example, we obtain • in d dimensions, an algorithm to answer n offline orthogonal range counting queries in time O(n lg d−2+1/d n); • an improved construction time for online data structures for orthogonal range counting; • an improved update time for the partial sums problem; • faster Word RAM algorithms for finding the maximum depth in an arrangement of axisaligned rectangles, and for the slope selection problem. As a bonus, we also give a simple (1 + ε)approximation algorithm for counting inversions that runs in linear time, improving the previous O(n lg lg n) bound by Andersson and Petersson.
Betweenness Centrality: Algorithms and Lower Bounds
, 2008
"... One of the most fundamental problems in largescale network analysis is to determine the importance of a particular node in a network. Betweenness centrality is the most widely used metric to measure the importance of a node in a network. In this paper, we present a randomized parallel algorithm and ..."
Abstract

Cited by 16 (0 self)
 Add to MetaCart
One of the most fundamental problems in largescale network analysis is to determine the importance of a particular node in a network. Betweenness centrality is the most widely used metric to measure the importance of a node in a network. In this paper, we present a randomized parallel algorithm and an algebraic method for computing betweenness centrality of all nodes in a network. We prove that any pathcomparison based algorithm cannot compute betweenness in less than O(nm) time.
Fast algorithms for (max,min)matrix multiplication and bottleneck shortest paths
 In Proc. 19th SODA
, 2009
"... Given a directed graph with a capacity on each edge, the allpairs bottleneck paths (APBP) problem is to determine, for all vertices s and t, the maximum flow that can be routed from s to t. For dense graphs this problem is equivalent to that of computing the (max, min)transitive closure of a realv ..."
Abstract

Cited by 14 (1 self)
 Add to MetaCart
(Show Context)
Given a directed graph with a capacity on each edge, the allpairs bottleneck paths (APBP) problem is to determine, for all vertices s and t, the maximum flow that can be routed from s to t. For dense graphs this problem is equivalent to that of computing the (max, min)transitive closure of a realvalued matrix. In this paper, we give a (max, min)matrix multiplication algorithm running in time O(n (3+ω)/2) ≤ O(n 2.688), where ω is the exponent of binary matrix multiplication. Our algorithm improves on a recent O(n 2+ω/3) ≤ O(n 2.792)time algorithm of Vassilevska, Williams, and Yuster. Although our algorithm is slower than the best APBP algorithm on vertex capacitated graphs, running in O(n 2.575) time, it is just as efficient as the best algorithm for computing the dominance product, a problem closely related to (max, min)matrix multiplication. Our techniques can be extended to give subcubic algorithms for related bottleneck problems. The allpairs bottleneck shortest paths problem (APBSP) asks for the maximum flow that can be routed along a shortest path. We give an APBSP algorithm for edgecapacitated graphs running in O(n (3+ω)/2) time and a slightly faster O(n 2.657)time algorithm for vertexcapactitated graphs. The second algorithm significantly improves on an O(n2.859)time APBSP algorithm of Shapira, Yuster, and Zwick. Our APBSP algorithms make use of new hybrid products we call the distancemaxmin product and dominancedistance product. 1
Sparse RNA folding: Time and space efficient algorithms
 IN: CPM
, 2009
"... The classical algorithm for RNA single strand folding requires O(nZ) time and O(n²) space, where n denotes the length of the input sequence and Z is a sparsity parameter which satisfies n ≤ Z ≤ n 2. We show how to reduce the space complexity of this algorithm. The space reduction is based on the o ..."
Abstract

Cited by 13 (7 self)
 Add to MetaCart
The classical algorithm for RNA single strand folding requires O(nZ) time and O(n²) space, where n denotes the length of the input sequence and Z is a sparsity parameter which satisfies n ≤ Z ≤ n 2. We show how to reduce the space complexity of this algorithm. The space reduction is based on the observation that some solutions for subproblems are not examined after a certain stage of the algorithm, and may be discarded from memory. This yields an O(nZ) time and O(Z) space algorithm, which outputs both the cardinality of the optimal folding as well as a corresponding secondary structure. The spaceefficient approach also extends to the related RNA simultaneous alignment with folding problem, and can be applied to reduce the space complexity of the fastest algorithm for this problem from O(n 2 m 2) down to O(nm 2 + ˜ Z), where where n and m denote the lengths of the input sequences to be aligned (w.l.o.g. m ≤ n), and ˜ Z is a sparsity parameter which satisfies nm ≤ ˜ Z ≤ n 2 m 2. In addition, we also show how to speed up the max basepair variant of RNA single strand folding. The speed up is achieved by combining two independent existing techniques, which restrict the number of expressions that need to be examined in bottleneck computations of these algorithms. This yields an O(LZ) time and O(Z) space algorithm, where L denotes the maximum cardinality of a folding of the input sequence.