10 research outputs found
MinMax-Profiles: A Unifying View of Common Intervals, Nested Common Intervals and Conserved Intervals of K Permutations
Common intervals of K permutations over the same set of n elements were
firstly investigated by T. Uno and M.Yagiura (Algorithmica, 26:290:309, 2000),
who proposed an efficient algorithm to find common intervals when K=2. Several
particular classes of intervals have been defined since then, e.g. conserved
intervals and nested common intervals, with applications mainly in genome
comparison. Each such class, including common intervals, led to the development
of a specific algorithmic approach for K=2, and - except for nested common
intervals - for its extension to an arbitrary K.
In this paper, we propose a common and efficient algorithmic framework for
finding different types of common intervals in a set P of K permutations, with
arbitrary K. Our generic algorithm is based on a global representation of the
information stored in P, called the MinMax-profile of P, and an efficient data
structure, called an LR-stack, that we introduce here. We show that common
intervals (and their subclasses of irreducible common intervals and same-sign
common intervals), nested common intervals (and their subclass of maximal
nested common intervals) as well as conserved intervals (and their subclass of
irreducible conserved intervals) may be obtained by appropriately setting the
parameters of our algorithm in each case. All the resulting algorithms run in
O(Kn+N)-time and need O(n) additional space, where N is the number of
solutions. The algorithms for nested common intervals and maximal nested common
intervals are new for K>2, in the sense that no other algorithm has been given
so far to solve the problem with the same complexity, or better. The other
algorithms are as efficient as the best known algorithms.Comment: 25 pages, 2 figure
Faster Deterministic Modular Subset Sum
We consider the Modular Subset Sum problem: given a multiset X of integers from ?_m and a target integer t, decide if there exists a subset of X with a sum equal to t (mod m). Recent independent works by Cardinal and Iacono (SOSA\u2721), and Axiotis et al. (SOSA\u2721) provided simple and near-linear algorithms for this problem. Cardinal and Iacono gave a randomized algorithm that runs in ?(m log m) time, while Axiotis et al. gave a deterministic algorithm that runs in ?(m polylog m) time. Both results work by reduction to a text problem, which is solved using a dynamic strings data structure.
In this work, we develop a simple data structure, designed specifically to handle the text problem that arises in the algorithms for Modular Subset Sum. Our data structure, which we call the shift-tree, is a simple variant of a segment tree. We provide both a hashing-based and a deterministic variant of the shift-trees.
We then apply our data structure to the Modular Subset Sum problem and obtain two algorithms. The first algorithm is Monte-Carlo randomized and matches the ?(m log m) runtime of the Las-Vegas algorithm by Cardinal and Iacono. The second algorithm is fully deterministic and runs in ?(m log m ? ?(m)) time, where ? is the inverse Ackermann function
Solving problems on graphs using elimination algorithms
This diploma thesis deals with solving problems in graphs using elimination algorithms. It contains theoretical basis and experimental work. We compare solving of selected problems using greedy and elimination algorithms. They were tested on dominating set, graph coloring and vertex cover problems. In this thesis we present the problems, the implementations and the results of the comparison between them
Union-find-delete-algoritmien vertailua
Union-find-algoritmi on tehokas ratkaisu erillisten joukkojen käsittelyongelmaan. Union-find-delete-algoritmissa siihen on lisätty poiston mahdollisuus. Esittelen tässä tutkielmassa useita union-find-algoritmeja ja union-find-delete-algoritmeja ja vertailen niitä teoreettisesti ja kokeellisesti.
Toteutin kolme erilaista union-find-delete-algoritmia, ja testasin niitä satunnaisilla syötteillä. Toteuttamani algoritmit ovat Ben-Amramin ja Yoffen algoritmi, aidon poiston algoritmi ja vajaan poiston algoritmi. Testieni perusteella vaikuttaa siltä, että asymptoottiselta aikavaatimukseltaan huonompi aidon poiston algoritmi toimii keskimäärin yhtä hyvin tai jopa paremmin kuin Ben-Amramin ja Yoffen algoritmi, jossa poisto tehdään vakioajassa
Union-Find with Constant Time Deletions
A union-find data structure maintains a collection of disjoint sets under the operations makeset, union, and find. Kaplan, Shafrir, and Tarjan [SODA 2002] designed data structures for an extension of the union-find problem in which items of the sets maintained may be deleted. The cost of a delete operation in their implementations is essentially the same as the cost of a find operation; namely,
O
(log
n
) worst-case and
O
(α
⌈
M
/
N
⌉
(
n
)) amortized, where
n
is the number of items in the set returned by the find operation,
N
is the total number of makeset operations performed,
M
is the total number of find operations performed, and α
⌈
M
/
N
⌉
(
n
) is a functional inverse of Ackermann’s function. They left open the question whether delete operations can be implemented more efficiently than find operations, for example, in
o
(log
n
) worst-case time. We resolve this open problem by presenting a relatively simple modification of the classical union-find data structure that supports delete, as well as makeset and union operations, in
constant
worst-case time, while still supporting find operations in
O
(log
n
) worst-case time and
O
(α
⌈ M/N⌉
(
n
)) amortized time.
Our analysis supplies, in particular, a very concise potential-based amortized analysis of the standard union-find data structure that yields an
O
(α
⌈
M
/
N
⌉
(
n
)) amortized bound on the cost of find operations. All previous potential-based analyses yielded the weaker amortized bound of
O
(α
⌈
M
/
N
⌉
(
N
)). Furthermore, our tighter analysis extends to one-path variants of the path compression technique such as
path splitting
.
</jats:p
Union-Find with Constant Time Deletions
A union-find data structure maintains a collection of disjoint sets under makeset, union and find operations. Kaplan, Shafrir and Tarjan [SODA 2002] designed data structures for an extension of the unionfind problem in which elements of the sets maintained may be deleted. The cost of a delete operation in their implementations is the same as the cost of a find operation. They left open the question whether delete operations can be implemented more efficiently than find operations. We resolve this open problem by presenting a relatively simple modification of the classical union-find data structure that supports delete, aswell as makeset and union, operations in constant time, while still supporting find operations in O(log n) worst-case time and O(α(n)) amortized time, where n is the number of elements in the set returned by the find operation, and α(n) is a functional inverse of Ackermann’s function