599 research outputs found
Solving weighted and counting variants of connectivity problems parameterized by treewidth deterministically in single exponential time
It is well known that many local graph problems, like Vertex Cover and
Dominating Set, can be solved in 2^{O(tw)}|V|^{O(1)} time for graphs G=(V,E)
with a given tree decomposition of width tw. However, for nonlocal problems,
like the fundamental class of connectivity problems, for a long time we did not
know how to do this faster than tw^{O(tw)}|V|^{O(1)}. Recently, Cygan et al.
(FOCS 2011) presented Monte Carlo algorithms for a wide range of connectivity
problems running in time $c^{tw}|V|^{O(1)} for a small constant c, e.g., for
Hamiltonian Cycle and Steiner tree. Naturally, this raises the question whether
randomization is necessary to achieve this runtime; furthermore, it is
desirable to also solve counting and weighted versions (the latter without
incurring a pseudo-polynomial cost in terms of the weights).
We present two new approaches rooted in linear algebra, based on matrix rank
and determinants, which provide deterministic c^{tw}|V|^{O(1)} time algorithms,
also for weighted and counting versions. For example, in this time we can solve
the traveling salesman problem or count the number of Hamiltonian cycles. The
rank-based ideas provide a rather general approach for speeding up even
straightforward dynamic programming formulations by identifying "small" sets of
representative partial solutions; we focus on the case of expressing
connectivity via sets of partitions, but the essential ideas should have
further applications. The determinant-based approach uses the matrix tree
theorem for deriving closed formulas for counting versions of connectivity
problems; we show how to evaluate those formulas via dynamic programming.Comment: 36 page
Solving Connectivity Problems Parameterized by Treedepth in Single-Exponential Time and Polynomial Space
A breakthrough result of Cygan et al. (FOCS 2011) showed that connectivity problems parameterized by treewidth can be solved much faster than the previously best known time ?^*(2^{?(twlog tw)}). Using their inspired Cut&Count technique, they obtained ?^*(?^tw) time algorithms for many such problems. Moreover, they proved these running times to be optimal assuming the Strong Exponential-Time Hypothesis. Unfortunately, like other dynamic programming algorithms on tree decompositions, these algorithms also require exponential space, and this is widely believed to be unavoidable. In contrast, for the slightly larger parameter called treedepth, there are already several examples of matching the time bounds obtained for treewidth, but using only polynomial space. Nevertheless, this has remained open for connectivity problems.
In the present work, we close this knowledge gap by applying the Cut&Count technique to graphs of small treedepth. While the general idea is unchanged, we have to design novel procedures for counting consistently cut solution candidates using only polynomial space. Concretely, we obtain time ?^*(3^d) and polynomial space for Connected Vertex Cover, Feedback Vertex Set, and Steiner Tree on graphs of treedepth d. Similarly, we obtain time ?^*(4^d) and polynomial space for Connected Dominating Set and Connected Odd Cycle Transversal
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
Parameterized Complexity of Secluded Connectivity Problems
The Secluded Path problem models a situation where a sensitive information
has to be transmitted between a pair of nodes along a path in a network. The
measure of the quality of a selected path is its exposure, which is the total
weight of vertices in its closed neighborhood. In order to minimize the risk of
intercepting the information, we are interested in selecting a secluded path,
i.e. a path with a small exposure. Similarly, the Secluded Steiner Tree problem
is to find a tree in a graph connecting a given set of terminals such that the
exposure of the tree is minimized. The problems were introduced by Chechik et
al. in [ESA 2013]. Among other results, Chechik et al. have shown that Secluded
Path is fixed-parameter tractable (FPT) on unweighted graphs being
parameterized by the maximum vertex degree of the graph and that Secluded
Steiner Tree is FPT parameterized by the treewidth of the graph. In this work,
we obtain the following results about parameterized complexity of secluded
connectivity problems.
We give FPT-algorithms deciding if a graph G with a given cost function
contains a secluded path and a secluded Steiner tree of exposure at most k with
the cost at most C.
We initiate the study of "above guarantee" parameterizations for secluded
problems, where the lower bound is given by the size of a Steiner tree.
We investigate Secluded Steiner Tree from kernelization perspective and
provide several lower and upper bounds when parameters are the treewidth, the
size of a vertex cover, maximum vertex degree and the solution size. Finally,
we refine the algorithmic result of Chechik et al. by improving the exponential
dependence from the treewidth of the input graph.Comment: Minor corrections are don
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
- …