Improving dynamic programming on tree decompositions

Speeding Up Dynamic Programming with Representative Sets: An Experimental Evaluation of Algorithms for Steiner Tree on Tree Decompositions

Algorithmica ◽

10.1007/s00453-014-9934-0 ◽

2014 ◽

Vol 71 (3) ◽

pp. 636-660 ◽

Cited By ~ 6

Author(s):

Stefan Fafianie ◽

Hans L. Bodlaender ◽

Jesper Nederlof

Keyword(s):

Dynamic Programming ◽

Steiner Tree ◽

Experimental Evaluation ◽

Tree Decompositions

Download Full-text

DynASP2.5: Dynamic Programming on Tree Decompositions in Action

Algorithms ◽

10.3390/a14030081 ◽

2021 ◽

Vol 14 (3) ◽

pp. 81

Author(s):

Johannes Fichte ◽

Markus Hecher ◽

Michael Morak ◽

Stefan Woltran

Keyword(s):

Dynamic Programming ◽

Vertex Cover ◽

Steiner Tree Problem ◽

Polynomial Hierarchy ◽

Competitive Behavior ◽

Parameterized Algorithms ◽

Sat Solving ◽

Tree Decompositions ◽

Answer Sets ◽

Answer Set

Efficient exact parameterized algorithms are an active research area. Such algorithms exhibit a broad interest in the theoretical community. In the last few years, implementations for computing various parameters (parameter detection) have been established in parameterized challenges, such as treewidth, treedepth, hypertree width, feedback vertex set, or vertex cover. In theory, instances, for which the considered parameter is small, can be solved fast (problem evaluation), i.e., the runtime is bounded exponential in the parameter. While such favorable theoretical guarantees exists, it is often unclear whether one can successfully implement these algorithms under practical considerations. In other words, can we design and construct implementations of parameterized algorithms such that they perform similar or even better than well-established problem solvers on instances where the parameter is small. Indeed, we can build an implementation that performs well under the theoretical assumptions. However, it could also well be that an existing solver implicitly takes advantage of a structure, which is often claimed for solvers that build on Sat-solving. In this paper, we consider finding one solution to instances of answer set programming (ASP), which is a logic-based declarative modeling and solving framework. Solutions for ASP instances are so-called answer sets. Interestingly, the problem of deciding whether an instance has an answer set is already located on the second level of the polynomial hierarchy. An ASP solver that employs treewidth as parameter and runs dynamic programming on tree decompositions is DynASP2. Empirical experiments show that this solver is fast on instances of small treewidth and can outperform modern ASP when one counts answer sets. It remains open, whether one can improve the solver such that it also finds one answer set fast and shows competitive behavior to modern ASP solvers on instances of low treewidth. Unfortunately, theoretical models of modern ASP solvers already indicate that these solvers can solve instances of low treewidth fast, since they are based on Sat-solving algorithms. In this paper, we improve DynASP2 and construct the solver DynASP2.5, which uses a different approach. The new solver shows competitive behavior to state-of-the-art ASP solvers even for finding just one solution. We present empirical experiments where one can see that our new implementation solves ASP instances, which encode the Steiner tree problem on graphs with low treewidth, fast. Our implementation is based on a novel approach that we call multi-pass dynamic programming (MDPSINC). In the paper, we describe the underlying concepts of our implementation (DynASP2.5) and we argue why the techniques still yield correct algorithms.

Download Full-text

Improving TSP Tours Using Dynamic Programming over Tree Decompositions

ACM Transactions on Algorithms ◽

10.1145/3341730 ◽

2019 ◽

Vol 15 (4) ◽

pp. 1-19 ◽

Cited By ~ 2

Author(s):

Marek Cygan ◽

Łukasz Kowalik ◽

Arkadiusz Socała

Keyword(s):

Dynamic Programming ◽

Tree Decompositions

Download Full-text

Improving the Efficiency of Dynamic Programming on Tree Decompositions via Machine Learning

Journal of Artificial Intelligence Research ◽

10.1613/jair.5312 ◽

2017 ◽

Vol 58 ◽

pp. 829-858 ◽

Cited By ~ 5

Author(s):

Michael Abseher ◽

Nysret Musliu ◽

Stefan Woltran

Keyword(s):

Machine Learning ◽

Dynamic Programming ◽

Tree Decomposition ◽

Machine Learning Techniques ◽

Problem Instance ◽

Actual Problem ◽

Learning Techniques ◽

Tree Decompositions ◽

Selection Of ◽

General Method

Dynamic Programming (DP) over tree decompositions is a well-established method to solve problems - that are in general NP-hard - efficiently for instances of small treewidth. Experience shows that (i) heuristically computing a tree decomposition has negligible runtime compared to the DP step; and (ii) DP algorithms exhibit a high variance in runtime when using different tree decompositions; in fact, given an instance of the problem at hand, even decompositions of the same width might yield extremely diverging runtimes. We thus propose here a novel and general method that is based on selection of the best decomposition from an available pool of heuristically generated ones. For this purpose, we require machine learning techniques that provide automated selection based on features of the decomposition rather than on the actual problem instance. Thus, one main contribution of this work is to propose novel features for tree decompositions. Moreover, we report on extensive experiments in different problem domains which show a significant speedup when choosing the tree decomposition according to this concept over simply using an arbitrary one of the same width.

Download Full-text

Dynamic Programming on Tree Decompositions Using Generalised Fast Subset Convolution

Lecture Notes in Computer Science - Algorithms - ESA 2009 ◽

10.1007/978-3-642-04128-0_51 ◽

2009 ◽

pp. 566-577 ◽

Cited By ~ 40

Author(s):

Johan M. M. van Rooij ◽

Hans L. Bodlaender ◽

Peter Rossmanith

Keyword(s):

Dynamic Programming ◽

Tree Decompositions

Download Full-text

Practical Access to Dynamic Programming on Tree Decompositions

Algorithms ◽

10.3390/a12080172 ◽

2019 ◽

Vol 12 (8) ◽

pp. 172 ◽

Cited By ~ 1

Author(s):

Max Bannach ◽

Sebastian Berndt

Keyword(s):

Dynamic Programming ◽

Algorithm Design ◽

Model Checker ◽

Simple Fact ◽

Small Width ◽

Wide Range ◽

Dynamic Programs ◽

Interface Dynamic ◽

Tree Decompositions ◽

Update Rules

Parameterized complexity theory has led to a wide range of algorithmic breakthroughs within the last few decades, but the practicability of these methods for real-world problems is still not well understood. We investigate the practicability of one of the fundamental approaches of this field: dynamic programming on tree decompositions. Indisputably, this is a key technique in parameterized algorithms and modern algorithm design. Despite the enormous impact of this approach in theory, it still has very little influence on practical implementations. The reasons for this phenomenon are manifold. One of them is the simple fact that such an implementation requires a long chain of non-trivial tasks (as computing the decomposition, preparing it, …). We provide an easy way to implement such dynamic programs that only requires the definition of the update rules. With this interface, dynamic programs for various problems, such as 3-coloring, can be implemented easily in about 100 lines of structured Java code. The theoretical foundation of the success of dynamic programming on tree decompositions is well understood due to Courcelle’s celebrated theorem, which states that every MSO-definable problem can be efficiently solved if a tree decomposition of small width is given. We seek to provide practical access to this theorem as well, by presenting a lightweight model checker for a small fragment of MSO 1 (that is, we do not consider “edge-set-based” problems). This fragment is powerful enough to describe many natural problems, and our model checker turns out to be very competitive against similar state-of-the-art tools.

Download Full-text