5,958 research outputs found
Convex Hull of Points Lying on Lines in o(n log n) Time after Preprocessing
Motivated by the desire to cope with data imprecision, we study methods for
taking advantage of preliminary information about point sets in order to speed
up the computation of certain structures associated with them.
In particular, we study the following problem: given a set L of n lines in
the plane, we wish to preprocess L such that later, upon receiving a set P of n
points, each of which lies on a distinct line of L, we can construct the convex
hull of P efficiently. We show that in quadratic time and space it is possible
to construct a data structure on L that enables us to compute the convex hull
of any such point set P in O(n alpha(n) log* n) expected time. If we further
assume that the points are "oblivious" with respect to the data structure, the
running time improves to O(n alpha(n)). The analysis applies almost verbatim
when L is a set of line-segments, and yields similar asymptotic bounds. We
present several extensions, including a trade-off between space and query time
and an output-sensitive algorithm. We also study the "dual problem" where we
show how to efficiently compute the (<= k)-level of n lines in the plane, each
of which lies on a distinct point (given in advance).
We complement our results by Omega(n log n) lower bounds under the algebraic
computation tree model for several related problems, including sorting a set of
points (according to, say, their x-order), each of which lies on a given line
known in advance. Therefore, the convex hull problem under our setting is
easier than sorting, contrary to the "standard" convex hull and sorting
problems, in which the two problems require Theta(n log n) steps in the worst
case (under the algebraic computation tree model).Comment: 26 pages, 5 figures, 1 appendix; a preliminary version appeared at
SoCG 201
The Quantum Complexity of Set Membership
We study the quantum complexity of the static set membership problem: given a
subset S (|S| \leq n) of a universe of size m (m \gg n), store it as a table of
bits so that queries of the form `Is x \in S?' can be answered. The goal is to
use a small table and yet answer queries using few bitprobes. This problem was
considered recently by Buhrman, Miltersen, Radhakrishnan and Venkatesh, where
lower and upper bounds were shown for this problem in the classical
deterministic and randomized models. In this paper, we formulate this problem
in the "quantum bitprobe model" and show tradeoff results between space and
time.In this model, the storage scheme is classical but the query scheme is
quantum.We show, roughly speaking, that similar lower bounds hold in the
quantum model as in the classical model, which imply that the classical upper
bounds are more or less tight even in the quantum case. Our lower bounds are
proved using linear algebraic techniques.Comment: 19 pages, a preliminary version appeared in FOCS 2000. This is the
journal version, which will appear in Algorithmica (Special issue on Quantum
Computation and Quantum Cryptography). This version corrects some bugs in the
parameters of some theorem
Quasipolynomial Hitting Sets for Circuits with Restricted Parse Trees
We study the class of non-commutative Unambiguous circuits or Unique-Parse-Tree (UPT) circuits, and a related model of Few-Parse-Trees (FewPT) circuits (which were recently introduced by Lagarde, Malod and Perifel [Guillaume Lagarde et al., 2016] and Lagarde, Limaye and Srinivasan [Guillaume Lagarde et al., 2017]) and give the following constructions:
- An explicit hitting set of quasipolynomial size for UPT circuits,
- An explicit hitting set of quasipolynomial size for FewPT circuits (circuits with constantly many parse tree shapes),
- An explicit hitting set of polynomial size for UPT circuits (of known parse tree shape), when a parameter of preimage-width is bounded by a constant.
The above three results are extensions of the results of [Manindra Agrawal et al., 2015], [Rohit Gurjar et al., 2015] and [Rohit Gurjar et al., 2016] to the setting of UPT circuits, and hence also generalize their results in the commutative world from read-once oblivious algebraic branching programs (ROABPs) to UPT-set-multilinear circuits.
The main idea is to study shufflings of non-commutative polynomials, which can then be used to prove suitable depth reduction results for UPT circuits and thereby allow a careful translation of the ideas in [Manindra Agrawal et al., 2015], [Rohit Gurjar et al., 2015] and [Rohit Gurjar et al., 2016]
Four Soviets Walk the Dog-Improved Bounds for Computing the Fr\'echet Distance
Given two polygonal curves in the plane, there are many ways to define a
notion of similarity between them. One popular measure is the Fr\'echet
distance. Since it was proposed by Alt and Godau in 1992, many variants and
extensions have been studied. Nonetheless, even more than 20 years later, the
original algorithm by Alt and Godau for computing the Fr\'echet
distance remains the state of the art (here, denotes the number of edges on
each curve). This has led Helmut Alt to conjecture that the associated decision
problem is 3SUM-hard.
In recent work, Agarwal et al. show how to break the quadratic barrier for
the discrete version of the Fr\'echet distance, where one considers sequences
of points instead of polygonal curves. Building on their work, we give a
randomized algorithm to compute the Fr\'echet distance between two polygonal
curves in time on a pointer machine
and in time on a word RAM. Furthermore, we show that
there exists an algebraic decision tree for the decision problem of depth
, for some . We believe that this
reveals an intriguing new aspect of this well-studied problem. Finally, we show
how to obtain the first subquadratic algorithm for computing the weak Fr\'echet
distance on a word RAM.Comment: 34 pages, 15 figures. A preliminary version appeared in SODA 201
Computing Real Roots of Real Polynomials ... and now For Real!
Very recent work introduces an asymptotically fast subdivision algorithm,
denoted ANewDsc, for isolating the real roots of a univariate real polynomial.
The method combines Descartes' Rule of Signs to test intervals for the
existence of roots, Newton iteration to speed up convergence against clusters
of roots, and approximate computation to decrease the required precision. It
achieves record bounds on the worst-case complexity for the considered problem,
matching the complexity of Pan's method for computing all complex roots and
improving upon the complexity of other subdivision methods by several
magnitudes.
In the article at hand, we report on an implementation of ANewDsc on top of
the RS root isolator. RS is a highly efficient realization of the classical
Descartes method and currently serves as the default real root solver in Maple.
We describe crucial design changes within ANewDsc and RS that led to a
high-performance implementation without harming the theoretical complexity of
the underlying algorithm.
With an excerpt of our extensive collection of benchmarks, available online
at http://anewdsc.mpi-inf.mpg.de/, we illustrate that the theoretical gain in
performance of ANewDsc over other subdivision methods also transfers into
practice. These experiments also show that our new implementation outperforms
both RS and mature competitors by magnitudes for notoriously hard instances
with clustered roots. For all other instances, we avoid almost any overhead by
integrating additional optimizations and heuristics.Comment: Accepted for presentation at the 41st International Symposium on
Symbolic and Algebraic Computation (ISSAC), July 19--22, 2016, Waterloo,
Ontario, Canad
Separation-Sensitive Collision Detection for Convex Objects
We develop a class of new kinetic data structures for collision detection
between moving convex polytopes; the performance of these structures is
sensitive to the separation of the polytopes during their motion. For two
convex polygons in the plane, let be the maximum diameter of the polygons,
and let be the minimum distance between them during their motion. Our
separation certificate changes times when the relative motion of
the two polygons is a translation along a straight line or convex curve,
for translation along an algebraic trajectory, and for
algebraic rigid motion (translation and rotation). Each certificate update is
performed in time. Variants of these data structures are also
shown that exhibit \emph{hysteresis}---after a separation certificate fails,
the new certificate cannot fail again until the objects have moved by some
constant fraction of their current separation. We can then bound the number of
events by the combinatorial size of a certain cover of the motion path by
balls.Comment: 10 pages, 8 figures; to appear in Proc. 10th Annual ACM-SIAM
Symposium on Discrete Algorithms, 1999; see also
http://www.uiuc.edu/ph/www/jeffe/pubs/kollide.html ; v2 replaces submission
with camera-ready versio
Recent Advances in Graph Partitioning
We survey recent trends in practical algorithms for balanced graph
partitioning together with applications and future research directions
- …