75 research outputs found
A Fast Parameterized Algorithm for Co-Path Set
The k-CO-PATH SET problem asks, given a graph G and a positive integer k,
whether one can delete k edges from G so that the remainder is a collection of
disjoint paths. We give a linear-time fpt algorithm with complexity
O^*(1.588^k) for deciding k-CO-PATH SET, significantly improving the previously
best known O^*(2.17^k) of Feng, Zhou, and Wang (2015). Our main tool is a new
O^*(4^{tw(G)}) algorithm for CO-PATH SET using the Cut&Count framework, where
tw(G) denotes treewidth. In general graphs, we combine this with a branching
algorithm which refines a 6k-kernel into reduced instances, which we prove have
bounded treewidth
Fast Monotone Summation over Disjoint Sets
We study the problem of computing an ensemble of multiple sums where the
summands in each sum are indexed by subsets of size of an -element
ground set. More precisely, the task is to compute, for each subset of size
of the ground set, the sum over the values of all subsets of size that are
disjoint from the subset of size . We present an arithmetic circuit that,
without subtraction, solves the problem using arithmetic
gates, all monotone; for constant , this is within the factor
of the optimal. The circuit design is based on viewing the summation as a "set
nucleation" task and using a tree-projection approach to implement the
nucleation. Applications include improved algorithms for counting heaviest
-paths in a weighted graph, computing permanents of rectangular matrices,
and dynamic feature selection in machine learning
Speeding-up Dynamic Programming with Representative Sets - An Experimental Evaluation of Algorithms for Steiner Tree on Tree Decompositions
Dynamic programming on tree decompositions is a frequently used approach to
solve otherwise intractable problems on instances of small treewidth. In recent
work by Bodlaender et al., it was shown that for many connectivity problems,
there exist algorithms that use time, linear in the number of vertices, and
single exponential in the width of the tree decomposition that is used. The
central idea is that it suffices to compute representative sets, and these can
be computed efficiently with help of Gaussian elimination.
In this paper, we give an experimental evaluation of this technique for the
Steiner Tree problem. A comparison of the classic dynamic programming algorithm
and the improved dynamic programming algorithm that employs the table reduction
shows that the new approach gives significant improvements on the running time
of the algorithm and the size of the tables computed by the dynamic programming
algorithm, and thus that the rank based approach from Bodlaender et al. does
not only give significant theoretical improvements but also is a viable
approach in a practical setting, and showcases the potential of exploiting the
idea of representative sets for speeding up dynamic programming algorithms
A practical fpt algorithm for Flow Decomposition and transcript assembly
The Flow Decomposition problem, which asks for the smallest set of weighted
paths that "covers" a flow on a DAG, has recently been used as an important
computational step in transcript assembly. We prove the problem is in FPT when
parameterized by the number of paths by giving a practical linear fpt
algorithm. Further, we implement and engineer a Flow Decomposition solver based
on this algorithm, and evaluate its performance on RNA-sequence data.
Crucially, our solver finds exact solutions while achieving runtimes
competitive with a state-of-the-art heuristic. Finally, we contextualize our
design choices with two hardness results related to preprocessing and weight
recovery. Specifically, -Flow Decomposition does not admit polynomial
kernels under standard complexity assumptions, and the related problem of
assigning (known) weights to a given set of paths is NP-hard.Comment: Introduces software package Toboggan: Version 1.0.
http://dx.doi.org/10.5281/zenodo.82163
Efficient FPT algorithms for (strict) compatibility of unrooted phylogenetic trees
In phylogenetics, a central problem is to infer the evolutionary
relationships between a set of species ; these relationships are often
depicted via a phylogenetic tree -- a tree having its leaves univocally labeled
by elements of and without degree-2 nodes -- called the "species tree". One
common approach for reconstructing a species tree consists in first
constructing several phylogenetic trees from primary data (e.g. DNA sequences
originating from some species in ), and then constructing a single
phylogenetic tree maximizing the "concordance" with the input trees. The
so-obtained tree is our estimation of the species tree and, when the input
trees are defined on overlapping -- but not identical -- sets of labels, is
called "supertree". In this paper, we focus on two problems that are central
when combining phylogenetic trees into a supertree: the compatibility and the
strict compatibility problems for unrooted phylogenetic trees. These problems
are strongly related, respectively, to the notions of "containing as a minor"
and "containing as a topological minor" in the graph community. Both problems
are known to be fixed-parameter tractable in the number of input trees , by
using their expressibility in Monadic Second Order Logic and a reduction to
graphs of bounded treewidth. Motivated by the fact that the dependency on
of these algorithms is prohibitively large, we give the first explicit dynamic
programming algorithms for solving these problems, both running in time
, where is the total size of the input.Comment: 18 pages, 1 figur
- …