Results 1  10
of
14
Sublinear time algorithms
 SIGACT News
, 2003
"... Abstract Sublinear time algorithms represent a new paradigm in computing, where an algorithmmust give some sort of an answer after inspecting only a very small portion of the input. We discuss the sorts of answers that one might be able to achieve in this new setting. 1 Introduction The goal of algo ..."
Abstract

Cited by 25 (3 self)
 Add to MetaCart
Abstract Sublinear time algorithms represent a new paradigm in computing, where an algorithmmust give some sort of an answer after inspecting only a very small portion of the input. We discuss the sorts of answers that one might be able to achieve in this new setting. 1 Introduction The goal of algorithmic research is to design efficient algorithms, where efficiency is typicallymeasured as a function of the length of the input. For instance, the elementary school algorithm for multiplying two n digit integers takes roughly n2 steps, while more sophisticated algorithmshave been devised which run in less than n log2 n steps. It is still not known whether a linear time algorithm is achievable for integer multiplication. Obviously any algorithm for this task, as for anyother nontrivial task, would need to take at least linear time in n, since this is what it would take to read the entire input and write the output. Thus, showing the existence of a linear time algorithmfor a problem was traditionally considered to be the gold standard of achievement. Nevertheless, due to the recent tremendous increase in computational power that is inundatingus with a multitude of data, we are now encountering a paradigm shift from traditional computational models. The scale of these data sets, coupled with the typical situation in which there is verylittle time to perform our computations, raises the issue of whether there is time to consider any more than a miniscule fraction of the data in our computations? Analogous to the reasoning thatwe used for multiplication, for most natural problems, an algorithm which runs in sublinear time must necessarily use randomization and must give an answer which is in some sense imprecise.Nevertheless, there are many situations in which a fast approximate solution is more useful than a slower exact solution.
Sublineartime algorithms
 In Oded Goldreich, editor, Property Testing, volume 6390 of Lecture Notes in Computer Science
, 2010
"... In this paper we survey recent (up to end of 2009) advances in the area of sublineartime algorithms. 1 ..."
Abstract

Cited by 12 (3 self)
 Add to MetaCart
In this paper we survey recent (up to end of 2009) advances in the area of sublineartime algorithms. 1
Counting Stars and Other Small Subgraphs in Sublinear Time
"... Detecting and counting the number of copies of certain subgraphs (also known as network motifs or graphlets), is motivated by applications in a variety of areas ranging from Biology to the study of the WorldWideWeb. Several polynomialtime algorithms have been suggested for counting or detecting t ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
Detecting and counting the number of copies of certain subgraphs (also known as network motifs or graphlets), is motivated by applications in a variety of areas ranging from Biology to the study of the WorldWideWeb. Several polynomialtime algorithms have been suggested for counting or detecting the number of occurrences of certain network motifs. However, a need for more efficient algorithms arises when the input graph is very large, as is indeed the case in many applications of motif counting. In this paper we design sublineartime algorithms for approximating the number of copies of certain constantsize subgraphs in a graph G. That is, our algorithms do not read the whole graph, but rather query parts of the graph. Specifically, we consider algorithms that may query the degree of any vertex of their choice and may ask for any neighbor of any vertex of their choice. The main focus of this work is on the basic problem of counting the number of length2 paths and more generally on counting the number of stars of a certain size. Specifically, we design an algorithm that, given an approximation parameter 0 < ɛ < 1 and query access to a graph G, outputs an estimate ˆνs such that with high constant probability, (1−ɛ)νs(G) ≤ ˆνs ≤ (1+ɛ)νs(G), where νs(G) denotes the number of stars of size s + 1 in the graph. The expected query ( complexity and { running time of}) the algorithm are O
Facility location in sublinear time
 In 32nd International Colloquium on Automata, Languages, and Programming
, 2005
"... Abstract. In this paper we present a randomized constant factor approximation algorithm for the problem of computing the optimal cost of the metric Minimum Facility Location problem, in the case of uniform costs and uniform demands, and in which every point can open a facility. By exploiting the fac ..."
Abstract

Cited by 8 (1 self)
 Add to MetaCart
Abstract. In this paper we present a randomized constant factor approximation algorithm for the problem of computing the optimal cost of the metric Minimum Facility Location problem, in the case of uniform costs and uniform demands, and in which every point can open a facility. By exploiting the fact that we are approximating the optimal cost without computing an actual solution, we give the first algorithm for this problem with running time O(n log 2 n), where n is the number of metric space points. Since the size of the representation of an npoint metric space is Θ(n 2), the complexity of our algorithm is sublinear with respect to the input size. We consider also the general version of the metric Minimum Facility Location problem and we show that there is no o(n 2)time algorithm, even a randomized one, that approximates the optimal solution to within any factor. This result can be generalized to some related problems, and in particular, the cost of minimumcost matching, the cost of bichromatic matching, or the cost of n/2median cannot be approximated in o(n 2)time. 1
Online geometric reconstruction
 Proc. of 22nd SOCG
, 2006
"... We investigate a new class of geometric problems based on the idea of online error correction. Suppose one is given access to a large geometric dataset though a query mechanism; for example, the dataset could be a terrain and a query might ask for the coordinates of a particular vertex or for the ed ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
We investigate a new class of geometric problems based on the idea of online error correction. Suppose one is given access to a large geometric dataset though a query mechanism; for example, the dataset could be a terrain and a query might ask for the coordinates of a particular vertex or for the edges incident to it. Suppose, in addition, that the dataset satisfies some known structural property P (eg, monotonicity or convexity) but that, because of errors and noise, the queries occasionally provide answers that violate P. Can one design a filter that modifies the query’s answers so that (i) the output satisfies P; (ii) the amount of data modification is minimized? We provide upper and lower bounds on the complexity of online reconstruction for convexity in 2D and 3D. 1
Approximating the Weight of the Euclidean Minimum Spanning Tree in Sublinear Time
"... We consider the problem of computing the weight of a Euclidean minimum spanning tree for a set of n points in Rd. We focus on the setting where the input point set is supported by certain basic (and commonly used) geometric data structures that can provide efficient access to the input in a struct ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
We consider the problem of computing the weight of a Euclidean minimum spanning tree for a set of n points in Rd. We focus on the setting where the input point set is supported by certain basic (and commonly used) geometric data structures that can provide efficient access to the input in a structured way. We present an algorithm that estimates with high probability the weight of a Euclidean minimum spanning tree of a set of points to within 1 + " using only eO(pn poly(1=")) queries for constant d. The algorithm assumes that the input is supported by a minimal bounding cube enclosing it, by orthogonal range queries, and by cone approximate nearest neighbors queries.
New Sublinear Methods in the Struggle against Classical Problems
, 2010
"... We study the time and query complexity of approximation algorithms that access only a minuscule fraction of the input, focusing on two classical sources of problems: combinatorial graph optimization and manipulation of strings. The tools we develop find applications outside of the area of sublinear ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
We study the time and query complexity of approximation algorithms that access only a minuscule fraction of the input, focusing on two classical sources of problems: combinatorial graph optimization and manipulation of strings. The tools we develop find applications outside of the area of sublinear algorithms. For instance, we obtain a more efficient approximation algorithm for edit distance and distributed algorithms for combinatorial problems on graphs that run in a constant number of communication rounds.
Testing Euclidean minimum spanning trees in the plane
 ACM Transactions on Algorithms
, 2007
"... Given a Euclidean graph G over a set P of n points in the plane, we are interested in verifying whether G is a Euclidean minimum spanning tree (EMST) of P or G differs from it in more than ǫn edges. We assume that G is given in adjacency list representation and the point/vertex set P is given in an ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
Given a Euclidean graph G over a set P of n points in the plane, we are interested in verifying whether G is a Euclidean minimum spanning tree (EMST) of P or G differs from it in more than ǫn edges. We assume that G is given in adjacency list representation and the point/vertex set P is given in an array. We present a property testing algorithm that accepts graph G if it is an EMST of P and that rejects with probability at least 2 3 if G differs from every EMST of P in more than ǫn edges. Our algorithm runs in O ( � n/ǫ · log2 (n/ǫ)) time and has a query complexity of O ( � n/ǫ · log(n/ǫ)).
A NearOptimal SublinearTime Algorithm for Approximating the Minimum Vertex Cover Size
, 2011
"... We give a nearly optimal sublineartime algorithm for approximating the size of a minimum vertex cover in a graph G. The algorithm may query the degree deg(v) of any vertex v of its choice, and for each 1 ≤ i ≤ deg(v), it may ask for the ith neighbor of v. Letting VCopt(G) denote the minimum size of ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We give a nearly optimal sublineartime algorithm for approximating the size of a minimum vertex cover in a graph G. The algorithm may query the degree deg(v) of any vertex v of its choice, and for each 1 ≤ i ≤ deg(v), it may ask for the ith neighbor of v. Letting VCopt(G) denote the minimum size of vertex cover in G, the algorithm outputs, with high constant success probability, an estimate ̂VC(G) such that VCopt(G) ≤ ̂ VC(G) ≤ 2VCopt(G) + ǫn, where ǫ is a given additive approximation parameter. We refer to such an estimate as a (2, ǫ)estimate. The query complexity and running time of the algorithm are Õ ( ¯ d · poly(1/ǫ)), where ¯ d denotes the average vertex degree in the graph. The best previously known sublinear algorithm, of Yoshida et al. (STOC 2009), has query complexity and running time O(d4 /ǫ2), where d is the maximum degree in the graph. Given the lower bound of Ω ( ¯ d) (for constant ǫ) for obtaining such an estimate (with any constant multiplicative factor) due to Parnas and Ron (TCS 2007), our result is nearly optimal. In the case that the graph is dense, that is, the number of edges is Θ(n2), we consider another model, in which the algorithm may ask, for any pair of vertices u and v, whether there is an edge between u and v. We show how to adapt the algorithm that uses neighbor queries to this model and obtain an
ConstantTime Approximation . . .
"... We present a technique for transforming classical approximation algorithms into constanttime algorithms that approximate the size of the optimal solution. Our technique is applicable to a certain subclass of algorithms that compute a solution in a constant number of phases. The technique is based o ..."
Abstract
 Add to MetaCart
We present a technique for transforming classical approximation algorithms into constanttime algorithms that approximate the size of the optimal solution. Our technique is applicable to a certain subclass of algorithms that compute a solution in a constant number of phases. The technique is based on greedily considering local improvements in random order. The problems amenable to our technique include