193 research outputs found
Dynamic Set Intersection
Consider the problem of maintaining a family of dynamic sets subject to
insertions, deletions, and set-intersection reporting queries: given , report every member of in any order. We show that in the word
RAM model, where is the word size, given a cap on the maximum size of
any set, we can support set intersection queries in
expected time, and updates in expected time. Using this algorithm
we can list all triangles of a graph in
expected time, where and
is the arboricity of . This improves a 30-year old triangle enumeration
algorithm of Chiba and Nishizeki running in time.
We provide an incremental data structure on that supports intersection
{\em witness} queries, where we only need to find {\em one} .
Both queries and insertions take O\paren{\sqrt \frac{N}{w/\log^2 w}} expected
time, where . Finally, we provide time/space tradeoffs for
the fully dynamic set intersection reporting problem. Using words of space,
each update costs expected time, each reporting query
costs expected time where
is the size of the output, and each witness query costs expected time.Comment: Accepted to WADS 201
Conditional Lower Bounds for Space/Time Tradeoffs
In recent years much effort has been concentrated towards achieving
polynomial time lower bounds on algorithms for solving various well-known
problems. A useful technique for showing such lower bounds is to prove them
conditionally based on well-studied hardness assumptions such as 3SUM, APSP,
SETH, etc. This line of research helps to obtain a better understanding of the
complexity inside P.
A related question asks to prove conditional space lower bounds on data
structures that are constructed to solve certain algorithmic tasks after an
initial preprocessing stage. This question received little attention in
previous research even though it has potential strong impact.
In this paper we address this question and show that surprisingly many of the
well-studied hard problems that are known to have conditional polynomial time
lower bounds are also hard when concerning space. This hardness is shown as a
tradeoff between the space consumed by the data structure and the time needed
to answer queries. The tradeoff may be either smooth or admit one or more
singularity points.
We reveal interesting connections between different space hardness
conjectures and present matching upper bounds. We also apply these hardness
conjectures to both static and dynamic problems and prove their conditional
space hardness.
We believe that this novel framework of polynomial space conjectures can play
an important role in expressing polynomial space lower bounds of many important
algorithmic problems. Moreover, it seems that it can also help in achieving a
better understanding of the hardness of their corresponding problems in terms
of time
Heaviest Induced Ancestors and Longest Common Substrings
Suppose we have two trees on the same set of leaves, in which nodes are
weighted such that children are heavier than their parents. We say a node from
the first tree and a node from the second tree are induced together if they
have a common leaf descendant. In this paper we describe data structures that
efficiently support the following heaviest-induced-ancestor query: given a node
from the first tree and a node from the second tree, find an induced pair of
their ancestors with maximum combined weight. Our solutions are based on a
geometric interpretation that enables us to find heaviest induced ancestors
using range queries. We then show how to use these results to build an
LZ-compressed index with which we can quickly find with high probability a
longest substring common to the indexed string and a given pattern
Space Efficient Two-Dimensional Orthogonal Colored Range Counting
In the two-dimensional orthogonal colored range counting problem, we
preprocess a set, , of colored points on the plane, such that given an
orthogonal query rectangle, the number of distinct colors of the points
contained in this rectangle can be computed efficiently.
For this problem, we design three new solutions, and the bounds of each can
be expressed in some form of time-space tradeoff.
By setting appropriate parameter values for these solutions, we can achieve
new specific results with (the space are in words and is an
arbitrary constant in ):
** space and query time;
** space and query time;
** space and
query time;
** space and query time.
A known conditional lower bound to this problem based on Boolean matrix
multiplication gives some evidence on the difficulty of achieving near-linear
space solutions with query time better than by more than a
polylogarithmic factor using purely combinatorial approaches. Thus the time and
space bounds in all these results are efficient.
Previously, among solutions with similar query times, the most
space-efficient solution uses space to answer queries in
time (SIAM. J. Comp.~2008).
Thus the new results listed above all achieve improvements in space
efficiency, while all but the last result achieve speed-up in query time as
well.Comment: full version of an ESA 2021 pape
Efficient Loop Detection in Forwarding Networks and Representing Atoms in a Field of Sets
The problem of detecting loops in a forwarding network is known to be
NP-complete when general rules such as wildcard expressions are used. Yet,
network analyzer tools such as Netplumber (Kazemian et al., NSDI'13) or
Veriflow (Khurshid et al., NSDI'13) efficiently solve this problem in networks
with thousands of forwarding rules. In this paper, we complement such
experimental validation of practical heuristics with the first provably
efficient algorithm in the context of general rules. Our main tool is a
canonical representation of the atoms (i.e. the minimal non-empty sets) of the
field of sets generated by a collection of sets. This tool is particularly
suited when the intersection of two sets can be efficiently computed and
represented. In the case of forwarding networks, each forwarding rule is
associated with the set of packet headers it matches. The atoms then correspond
to classes of headers with same behavior in the network. We propose an
algorithm for atom computation and provide the first polynomial time algorithm
for loop detection in terms of number of classes (which can be exponential in
general). This contrasts with previous methods that can be exponential, even in
simple cases with linear number of classes. Second, we introduce a notion of
network dimension captured by the overlapping degree of forwarding rules. The
values of this measure appear to be very low in practice and constant
overlapping degree ensures polynomial number of header classes. Forwarding loop
detection is thus polynomial in forwarding networks with constant overlapping
degree
On Ray Shooting for Triangles in 3-Space and Related Problems
We consider several problems that involve lines in three dimensions, and
present improved algorithms for solving them. The problems include (i) ray
shooting amid triangles in , (ii) reporting intersections between query
lines (segments, or rays) and input triangles, as well as approximately
counting the number of such intersections, (iii) computing the intersection of
two nonconvex polyhedra, (iv) detecting, counting, or reporting intersections
in a set of lines in , and (v) output-sensitive construction of an
arrangement of triangles in three dimensions.
Our approach is based on the polynomial partitioning technique.
For example, our ray-shooting algorithm processes a set of triangles in
into a data structure for answering ray shooting queries amid the given
triangles, which uses storage and preprocessing, and
answers a query in time, for any . This
is a significant improvement over known results, obtained more than 25 years
ago, in which, with this amount of storage, the query time bound is roughly
. The algorithms for the other problems have similar performance
bounds, with similar improvements over previous results.
We also derive a nontrivial improved tradeoff between storage and query time.
Using it, we obtain algorithms that answer queries on objects in time, for any
, again an improvement over the earlier bounds.Comment: 33 pages, 7 figure
Succinct Indices for Range Queries with applications to Orthogonal Range Maxima
We consider the problem of preprocessing points in 2D, each endowed with
a priority, to answer the following queries: given a axis-parallel rectangle,
determine the point with the largest priority in the rectangle. Using the ideas
of the \emph{effective entropy} of range maxima queries and \emph{succinct
indices} for range maxima queries, we obtain a structure that uses O(N) words
and answers the above query in time. This is a direct
improvement of Chazelle's result from FOCS 1985 for this problem -- Chazelle
required words to answer queries in
time for any constant .Comment: To appear in ICALP 201
- …