96 research outputs found
Space Saving by Dynamic Algebraization
Dynamic programming is widely used for exact computations based on tree
decompositions of graphs. However, the space complexity is usually exponential
in the treewidth. We study the problem of designing efficient dynamic
programming algorithm based on tree decompositions in polynomial space. We show
how to construct a tree decomposition and extend the algebraic techniques of
Lokshtanov and Nederlof such that the dynamic programming algorithm runs in
time , where is the maximum number of vertices in the union of
bags on the root to leaf paths on a given tree decomposition, which is a
parameter closely related to the tree-depth of a graph. We apply our algorithm
to the problem of counting perfect matchings on grids and show that it
outperforms other polynomial-space solutions. We also apply the algorithm to
other set covering and partitioning problems.Comment: 14 pages, 1 figur
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
Hamiltonian Cycle Parameterized by Treedepth in Single Exponential Time and Polynomial Space
For many algorithmic problems on graphs of treewidth , a standard dynamic
programming approach gives an algorithm with time and space complexity
. It turns out that when one
considers the more restrictive parameter treedepth, it is often the case that a
variation of this technique can be used to reduce the space complexity to
polynomial, while retaining time complexity of the form
, where is the treedepth. This
transfer of methodology is, however, far from automatic. For instance, for
problems with connectivity constraints, standard dynamic programming techniques
give algorithms with time and space complexity on graphs of treewidth , but it is not clear how to
convert them into time-efficient polynomial space algorithms for graphs of low
treedepth.
Cygan et al. (FOCS'11) introduced the Cut&Count technique and showed that a
certain class of problems with connectivity constraints can be solved in time
and space complexity . Recently,
Hegerfeld and Kratsch (STACS'20) showed that, for some of those problems, the
Cut&Count technique can be also applied in the setting of treedepth, and it
gives algorithms with running time
and polynomial space usage. However, a number of important problems eluded such
a treatment, with the most prominent examples being Hamiltonian Cycle and
Longest Path.
In this paper we clarify the situation by showing that Hamiltonian Cycle,
Hamiltonian Path, Long Cycle, Long Path, and Min Cycle Cover all admit
-time and polynomial space algorithms on graphs of
treedepth . The algorithms are randomized Monte Carlo with only false
negatives.Comment: Presented at WG2020. 20 pages, 2 figure
Space--Time Tradeoffs for Subset Sum: An Improved Worst Case Algorithm
The technique of Schroeppel and Shamir (SICOMP, 1981) has long been the most
efficient way to trade space against time for the SUBSET SUM problem. In the
random-instance setting, however, improved tradeoffs exist. In particular, the
recently discovered dissection method of Dinur et al. (CRYPTO 2012) yields a
significantly improved space--time tradeoff curve for instances with strong
randomness properties. Our main result is that these strong randomness
assumptions can be removed, obtaining the same space--time tradeoffs in the
worst case. We also show that for small space usage the dissection algorithm
can be almost fully parallelized. Our strategy for dealing with arbitrary
instances is to instead inject the randomness into the dissection process
itself by working over a carefully selected but random composite modulus, and
to introduce explicit space--time controls into the algorithm by means of a
"bailout mechanism"
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
On space efficiency of algorithms working on structural decompositions of graphs
Dynamic programming on path and tree decompositions of graphs is a technique
that is ubiquitous in the field of parameterized and exponential-time
algorithms. However, one of its drawbacks is that the space usage is
exponential in the decomposition's width. Following the work of Allender et al.
[Theory of Computing, '14], we investigate whether this space complexity
explosion is unavoidable. Using the idea of reparameterization of Cai and
Juedes [J. Comput. Syst. Sci., '03], we prove that the question is closely
related to a conjecture that the Longest Common Subsequence problem
parameterized by the number of input strings does not admit an algorithm that
simultaneously uses XP time and FPT space. Moreover, we complete the complexity
landscape sketched for pathwidth and treewidth by Allender et al. by
considering the parameter tree-depth. We prove that computations on tree-depth
decompositions correspond to a model of non-deterministic machines that work in
polynomial time and logarithmic space, with access to an auxiliary stack of
maximum height equal to the decomposition's depth. Together with the results of
Allender et al., this describes a hierarchy of complexity classes for
polynomial-time non-deterministic machines with different restrictions on the
access to working space, which mirrors the classic relations between treewidth,
pathwidth, and tree-depth.Comment: An extended abstract appeared in the proceedings of STACS'16. The new
version is augmented with a space-efficient algorithm for Dominating Set
using the Chinese remainder theore
- …