209 research outputs found
Scalable Kernelization for Maximum Independent Sets
The most efficient algorithms for finding maximum independent sets in both
theory and practice use reduction rules to obtain a much smaller problem
instance called a kernel. The kernel can then be solved quickly using exact or
heuristic algorithms---or by repeatedly kernelizing recursively in the
branch-and-reduce paradigm. It is of critical importance for these algorithms
that kernelization is fast and returns a small kernel. Current algorithms are
either slow but produce a small kernel, or fast and give a large kernel. We
attempt to accomplish both of these goals simultaneously, by giving an
efficient parallel kernelization algorithm based on graph partitioning and
parallel bipartite maximum matching. We combine our parallelization techniques
with two techniques to accelerate kernelization further: dependency checking
that prunes reductions that cannot be applied, and reduction tracking that
allows us to stop kernelization when reductions become less fruitful. Our
algorithm produces kernels that are orders of magnitude smaller than the
fastest kernelization methods, while having a similar execution time.
Furthermore, our algorithm is able to compute kernels with size comparable to
the smallest known kernels, but up to two orders of magnitude faster than
previously possible. Finally, we show that our kernelization algorithm can be
used to accelerate existing state-of-the-art heuristic algorithms, allowing us
to find larger independent sets faster on large real-world networks and
synthetic instances.Comment: Extended versio
Streaming Kernelization
Kernelization is a formalization of preprocessing for combinatorially hard
problems. We modify the standard definition for kernelization, which allows any
polynomial-time algorithm for the preprocessing, by requiring instead that the
preprocessing runs in a streaming setting and uses
bits of memory on instances . We obtain
several results in this new setting, depending on the number of passes over the
input that such a streaming kernelization is allowed to make. Edge Dominating
Set turns out as an interesting example because it has no single-pass
kernelization but two passes over the input suffice to match the bounds of the
best standard kernelization
Mod/Resc Parsimony Inference
We address in this paper a new computational biology problem that aims at
understanding a mechanism that could potentially be used to genetically
manipulate natural insect populations infected by inherited, intra-cellular
parasitic bacteria. In this problem, that we denote by \textsc{Mod/Resc
Parsimony Inference}, we are given a boolean matrix and the goal is to find two
other boolean matrices with a minimum number of columns such that an
appropriately defined operation on these matrices gives back the input. We show
that this is formally equivalent to the \textsc{Bipartite Biclique Edge Cover}
problem and derive some complexity results for our problem using this
equivalence. We provide a new, fixed-parameter tractability approach for
solving both that slightly improves upon a previously published algorithm for
the \textsc{Bipartite Biclique Edge Cover}. Finally, we present experimental
results where we applied some of our techniques to a real-life data set.Comment: 11 pages, 3 figure
A shortcut to (sun)flowers: Kernels in logarithmic space or linear time
We investigate whether kernelization results can be obtained if we restrict
kernelization algorithms to run in logarithmic space. This restriction for
kernelization is motivated by the question of what results are attainable for
preprocessing via simple and/or local reduction rules. We find kernelizations
for d-Hitting Set(k), d-Set Packing(k), Edge Dominating Set(k) and a number of
hitting and packing problems in graphs, each running in logspace. Additionally,
we return to the question of linear-time kernelization. For d-Hitting Set(k) a
linear-time kernelization was given by van Bevern [Algorithmica (2014)]. We
give a simpler procedure and save a large constant factor in the size bound.
Furthermore, we show that we can obtain a linear-time kernel for d-Set
Packing(k) as well.Comment: 18 page
- âŠ