370,176 research outputs found
Improved Bounds for 3SUM, -SUM, and Linear Degeneracy
Given a set of real numbers, the 3SUM problem is to decide whether there
are three of them that sum to zero. Until a recent breakthrough by Gr{\o}nlund
and Pettie [FOCS'14], a simple -time deterministic algorithm for
this problem was conjectured to be optimal. Over the years many algorithmic
problems have been shown to be reducible from the 3SUM problem or its variants,
including the more generalized forms of the problem, such as -SUM and
-variate linear degeneracy testing (-LDT). The conjectured hardness of
these problems have become extremely popular for basing conditional lower
bounds for numerous algorithmic problems in P.
In this paper, we show that the randomized -linear decision tree
complexity of 3SUM is , and that the randomized -linear
decision tree complexity of -SUM and -LDT is , for any odd
. These bounds improve (albeit randomized) the corresponding
and decision tree bounds
obtained by Gr{\o}nlund and Pettie. Our technique includes a specialized
randomized variant of fractional cascading data structure. Additionally, we
give another deterministic algorithm for 3SUM that runs in time. The latter bound matches a recent independent bound by Freund
[Algorithmica 2017], but our algorithm is somewhat simpler, due to a better use
of word-RAM model
Deterministic counting of graph colourings using sequences of subgraphs
In this paper we propose a deterministic algorithm for approximately counting
the -colourings of sparse random graphs . In particular, our
algorithm computes in polynomial time a approximation of
the logarithm of the number of -colourings of for with high probability over the graph instances.
Our algorithm is related to the algorithms of A. Bandyopadhyay et al. in SODA
'06, and A. Montanari et al. in SODA '06, i.e. it uses {\em spatial correlation
decay} to compute {\em deterministically} marginals of {\em Gibbs
distribution}. We develop a scheme whose accuracy depends on {\em
non-reconstruction} of the colourings of , rather than {\em
uniqueness} that are required in previous works. This leaves open the
possibility for our schema to be sufficiently accurate even for .
The set up for establishing correlation decay is as follows: Given
, we alter the graph structure in some specific region of
the graph by deleting edges between vertices of . Then we show that
the effect of this change on the marginals of Gibbs distribution, diminishes as
we move away from . Our approach is novel and suggests a new context
for the study of deterministic counting algorithms
Dynamic Data Structures for k-Nearest Neighbor Queries
Our aim is to develop dynamic data structures that support -nearest neighbors (-NN) queries for a set of point sites in the plane in time, where is some polylogarithmic function of . The key component is a general query algorithm that allows us to find the -NN spread over substructures simultaneously, thus reducing an term in the query time to . Combining this technique with the logarithmic method allows us to turn any static -NN data structure into a data structure supporting both efficient insertions and queries. For the fully dynamic case, this technique allows us to recover the deterministic, worst-case, query time for the Euclidean distance claimed before, while preserving the polylogarithmic update times. We adapt this data structure to also support fully dynamic \emph{geodesic} -NN queries among a set of sites in a simple polygon. For this purpose, we design a shallow cutting based, deletion-only -NN data structure. More generally, we obtain a dynamic planar -NN data structure for any type of distance functions for which we can build vertical shallow cuttings. We apply all of our methods in the plane for the Euclidean distance, the geodesic distance, and general, constant-complexity, algebraic distance functions
Near Optimal Parallel Algorithms for Dynamic DFS in Undirected Graphs
Depth first search (DFS) tree is a fundamental data structure for solving
graph problems. The classical algorithm [SiComp74] for building a DFS tree
requires time for a given graph having vertices and edges.
Recently, Baswana et al. [SODA16] presented a simple algorithm for updating DFS
tree of an undirected graph after an edge/vertex update in time.
However, their algorithm is strictly sequential. We present an algorithm
achieving similar bounds, that can be adopted easily to the parallel
environment.
In the parallel model, a DFS tree can be computed from scratch using
processors in expected time [SiComp90] on an EREW PRAM, whereas
the best deterministic algorithm takes time
[SiComp90,JAlg93] on a CRCW PRAM. Our algorithm can be used to develop optimal
(upto polylog n factors deterministic algorithms for maintaining fully dynamic
DFS and fault tolerant DFS, of an undirected graph.
1- Parallel Fully Dynamic DFS:
Given an arbitrary online sequence of vertex/edge updates, we can maintain a
DFS tree of an undirected graph in time per update using
processors on an EREW PRAM.
2- Parallel Fault tolerant DFS:
An undirected graph can be preprocessed to build a data structure of size
O(m) such that for a set of updates (where is constant) in the graph,
the updated DFS tree can be computed in time using
processors on an EREW PRAM.
Moreover, our fully dynamic DFS algorithm provides, in a seamless manner,
nearly optimal (upto polylog n factors) algorithms for maintaining a DFS tree
in semi-streaming model and a restricted distributed model. These are the first
parallel, semi-streaming and distributed algorithms for maintaining a DFS tree
in the dynamic setting.Comment: Accepted to appear in SPAA'17, 32 Pages, 5 Figure
Counting Basic-Irreducible Factors Mod p^k in Deterministic Poly-Time and p-Adic Applications
Finding an irreducible factor, of a polynomial f(x) modulo a prime p, is not known to be in deterministic polynomial time. Though there is such a classical algorithm that counts the number of irreducible factors of f mod p. We can ask the same question modulo prime-powers p^k. The irreducible factors of f mod p^k blow up exponentially in number; making it hard to describe them. Can we count those irreducible factors mod p^k that remain irreducible mod p? These are called basic-irreducible. A simple example is in f=x^2+px mod p^2; it has p many basic-irreducible factors. Also note that, x^2+p mod p^2 is irreducible but not basic-irreducible!
We give an algorithm to count the number of basic-irreducible factors of f mod p^k in deterministic poly(deg(f),k log p)-time. This solves the open questions posed in (Cheng et al, ANTS\u2718 & Kopp et al, Math.Comp.\u2719). In particular, we are counting roots mod p^k; which gives the first deterministic poly-time algorithm to compute Igusa zeta function of f. Also, our algorithm efficiently partitions the set of all basic-irreducible factors (possibly exponential) into merely deg(f)-many disjoint sets, using a compact tree data structure and split ideals
Genome assembly from sequence reads
Assembling genomes can be roughly described as finding Eulerian tours in de Bruijn graphs. We present the theory behind (de Bruijn) graph data structures and describe some of the implementations.
A directed graph G(V,E) can be represented as a set of its edges in the form of ordered pairs vi → vj ∈ E. De Bruijn graphs are defined in a way that allows all possible neighbors of a node to be calculated from the given node’s label, which means that, given the adjacency set, we can navigate the graph by testing set membership. The edge set can be stored as a dictionary.
The dictionary can be either a deterministic data structure, like a tree or an FM-index, or a probabilistic data structure, like a Bloom filter.
In this thesis we present kBWT, a new space efficient deterministic data structure for storing a de Bruijn graph, which uses near-optimal n · σ + o(n) bits of memory, where n is the number of k-grams in the graph and σ is the size of the alphabet. It can retrieve neighborhood information for a given node in Θ(σ · k) time. We also compare it to an existing data structure found in the GATB framework, which is based on Bloom filters and therefore probabilistic. Benchmarks of the deterministic kBWT show it is slower in practice, compared to GATB’s data structure.
Testing showed kBWT had better cache efficiency, which did not make up for the number of processor cycles used for executing the algorithm
Automata and Differentiable Words
We exhibit the construction of a deterministic automaton that, given k > 0,
recognizes the (regular) language of k-differentiable words. Our approach
follows a scheme of Crochemore et al. based on minimal forbidden words. We
extend this construction to the case of C\infinity-words, i.e., words
differentiable arbitrary many times. We thus obtain an infinite automaton for
representing the set of C\infinity-words. We derive a classification of
C\infinity-words induced by the structure of the automaton. Then, we introduce
a new framework for dealing with \infinity-words, based on a three letter
alphabet. This allows us to define a compacted version of the automaton, that
we use to prove that every C\infinity-word admits a repetition in C\infinity
whose length is polynomially bounded.Comment: Accepted for publicatio
- …