Deterministic Single Exponential Time
Algorithms for Connectivity Problems
Parameterized by Treewidth
Hans L. Bodlaender
1
, Marek Cygan
2
, Stefan Kratsch
3
, and Jesper Nederlof
1
1
Utrecht University, The Netherlands
{H.L.Bodlaender,J.Nederlof}@uu.nl
2
University of Warsaw, Poland
cygan@mimuw.edu.pl
3
Technical University Berlin, Germany
stefan.kratsch@tu-berlin.de
Abstract. It is well known that many local graph problems, like Vertex
Cover and Dominating Set, can be solved in 2
O(tw)
n
O(1)
time for graphs
with a given tree decomposition of width tw. However, for nonlocal prob-
lems, like the fundamental class of connectivity problems, for a long time
it was unknown how to do this faster than tw
O(tw)
n
O(1)
until recently,
when Cygan et al. (FOCS 2011) introduced the Cut&Count technique
that gives randomized algorithms for a wide range of connectivity prob-
lems running in time c
tw
n
O(1)
for a small constant c.
In this paper, we show that we can improve upon the Cut&Count
technique in multiple ways, with two new techniques. The first tech-
nique (rank-based appr oach) gives deterministic algorithms with O(c
tw
n)
running time for connectivity problems (like Hamiltonian Cycle and
Stei-ner Tree) and for weighted variants of these; the second technique
(determinant approach) gives deterministic algorithms running in time
c
tw
n
O(1)
for counting versions, e.g., counting the number of Hamiltonian
cycles for graphs of treewidth tw.
The rank-based approach introduces a new technique to speed up dy-
namic programming algorithms which is likely to have more applications.
The determinant-based approach uses the Matrix Tree Theorem for de-
riving closed formulas for counting versions of connectivity problems; we
show how to evaluate those formulas via dynamic programming.
1 Introduction
It is known since the 1980s that many (NP-hard) problems allow algorithms
with a running time of the type f(tw)n
c
on graphs with n vertices and a tree
decomposition of width tw. It is a natural question how we can optimize on
The second author is partially supported by NCN grant DEC-2012/05/D/ST6/03214
and Foundation for Polish Science. Part of the work of the third author was done
at Utrecht University supported by the Nederlandse Organisatie voor Wetenschap-
pelijk Onderzoek (NWO), project: ’KERNELS’. The fourth author is supported by
the NWO project ’Space and Time Efficient Structural Improvements of Dynamic
Programming Algorithms’.
F.V. Fomin et al. (Eds.): ICALP 2013, Part I, LNCS 7965, pp. 196–207, 2013.
c
Springer-Verlag Berlin He idelberg 2013
Deterministic Single Exponential Time Algorithms 197
the dependency of the treewidth, i.e., we first aim at obtaining a small growing
(but, since we assume P = NP, exponential) function f(tw) and second a small
exponent c. For problems with locally checkable certificates, that is, certificates
assigning a constant number of bits per node that can be checked by a cardinality
check and iteratively looking at all neighborhoods of the input graph
1
,itquickly
became clear that f(tw) only needs to be single exponential. See [14,20] for
sample applications to the Independent Set/Vertex Cover problems. From
the work of [13] and known Karp-reductions between problems it follows that
this dependence cannot be improved to subexponential algorithms unless the
Exponential Time Hypothesis (ETH) fails. In [17] it was shown that under the
Strong ETH (SETH) the current algorithms are optimal even with respect to
the bases of the exponential dependence on the treewidth, that is, problems with
current best running time c
tw
n
O(1)
cannot be solved in (c−)
tw
n
O(1)
for positive
where, e.g., c =2forIndependent Set and c =3forDominating Set.
A natural class of problems that does not have locally checkable certificates are
connectivity problems such as Hamiltonian Cycle and Steiner Tree (see for
example [11, Section 5]), begging the question whether these can be solved within
single exponential dependence on tw as well. Early results on the special case of H-
minor-free graphs were given in [9]. A positive answer to the question was found
by Cygan et al. [8] using a randomized approach termed “Cut & Count”: It
provided a transformation of the natural certificates to “cut-certificates” trans-
forming the connectivity requirement into a locally checkable requirement. The
transformation is only valid modulo 2, but by a standard technique introduc-
ing randomization [19], the decision variant can be reduced to the counting
modulo 2 variant. This result was considered surprising since in the folklore
2
O(tw log tw)
n
O(1)
dynamic programming routines for connectivity problems all
information stored seemed needed: Given two partial solutions inducing differ-
ent connectivity properties, one can be extendable to a solution while the other
one can not (this resembles the notion of Myhill-Nerode equivalence classes [12]).
The Cut & Count approach is one of the dynamic programming algorithms
using a modulo 2 based transformation [3,4,16,15,18,23]. These algorithms give
the smallest running times currently known, but have several disadvantages
compared to traditional dynamic programming algorithms: (a) They are ran-
domized. (b) The dependence on the inputs weights in weighted extensions is
pseudo-polynomial. (c) They do not extend to counting the number of witnesses.
(d) They do not give intuition for the optimal substructure / equivalence classes.
An additional disadvantage of the Cut & Count approach of [8], compared to tra-
ditional dynamic programming algorithms on tree decompositions, is that their
dependence in terms of the input graph is superlinear. Our work shows that
each of these disadvantages can be overcome, with two different approaches,
both giving deterministic algorithms for connectivity problems that are single
exponential in the treewidth.
1
E.g., for the odd cycle transversal problem that asks to make the input graph bi-
partite by removing at most k vertices, a locally checkable certificate would be a
solution set combined with a proper two-coloring of the remaining graph.
198 H.L. Bodlaender et al.
Tab l e 1. Our results for some famous computational problems. The second column
gives running times when a path decomposition of width pw is given in the input; the
third column gives running times when a tree decomposition of width tw isgiveninthe
input. Rows 1–4 use the rank-based approach; Rows 5–7 the determinant approach. ω
denotes the matrix multiplication exponent (currently it is known that ω<2.3727 [24]).
1 Weighted Steiner Tree n(1 + 2
ω
)
pw
pw
O(1)
n(1 + 2
ω+1
)
tw
tw
O(1)
2 Traveling Salesman n(2 + 2
ω/2
)
pw
pw
O(1)
n(5 + 2
(ω+2)/2
)
tw
tw
O(1)
3 k-Pat h n(2 + 2
ω/2
)
pw
(k + pw)
O(1)
n(5 + 2
(ω+2)/2
)
tw
(k + tw)
O(1)
4 Feedback Vertex Set n(1 + 2
ω
)
pw
pw
O(1)
n(1 + 2
ω+1
)
tw
tw
O(1)
5 # Hamiltonian Cycle
˜
O(6
pw
pw
O(1)
n
2
)
˜
O(15
tw
tw
O(1)
n
2
)
6 # Steiner Tree
˜
O(5
pw
pw
O(1)
n
3
)
˜
O(10
tw
tw
O(1)
n
3
)
7 Feedback Vertex Set
˜
O(5
pw
pw
O(1)
n
3
)
˜
O(10
tw
tw
O(1)
n
3
)
Our Contribution. We present the “Rank based” and “Squared determinant”
approaches. For a number of key problems, we state the results obtained by
applying these approaches in Table 1.
The approaches can be used to quickly and deterministically solve weighted
and counting versions of problems solved by the Cut & Count approach. Addi-
tional advantages of the rank based approach are that it gives a more intuitive
insight in the optimal substructure / equivalence classes of a problem and that
is has only a linear dependence on the input graph in the running time. The
only disadvantage of both approaches when compared to the Cut & Count ap-
proach is that the dependence on the treewidth or pathwidth in the running
time is slightly worse. However, although we did not manage to overcome it,
this disadvantage might not be inherently due to the new methods. Due to the
generality of our key ideas, as one might expect, the approaches can be applied
to other connectivity problems, such as all problems mentioned in [8]. However,
our methods may inspire future work not involving tree decompositions as well.
Since one of the main strengths of the treewidth concept seems to be its
ubiquity, it is perhaps not surprising that our results improve, simplify, gen-
eralize or unify a number of seemingly unrelated results. E.g., we unify algo-
rithms for Feedba ck Vertex Set [6] and k-Pat h [2] and generalize algorithms
for restricted inputs such as H-minor-free (e.g. [9]) or bounded degree graphs
(e.g. [10]). A more detailed discussion is postponed to the full version.
For space reasons, many details (and material that might be considered ‘more
than details’) are omitted from this extended abstract. For all such material, we
refer to the full paper, available at arXiv.org [5].
2 Preliminaries
Partitions and the Partition Lattice. Given a base set U,weuseΠ(U)for
the set of all partitions of U. It is known that, together with the coarsening
relation , Π(U) gives a lattice, with the minimum element being {U} and
the maximum element being the partition into singletons. We denote for the
Deterministic Single Exponential Time Algorithms 199
meet operation and for the join operation in this lattice; these operators are
associative and commutative. We use Π
2
(U) ⊂ Π(U )todenotethesetofall
partitions of U in blocks of size 2, or equivalently, the set of perfect matchings
over U.Givenp ∈ Π(U), we let #blocks(p) denote the number of blocks of p.
If X ⊆ U we let p
↓X
∈ Π(X) be the partition obtained by removing all elements
not in X from it, and analogously we let for U ⊆ X denote p
↑X
∈ Π(X)for
the partition obtained by adding singletons for every element in X \ U to p.
Also, for X ⊆ U,weletU[X] be the partition of U where one block is {X} and
all other blocks are singletons. If a, b ∈ U we shorthand U [ab]=U[{a, b}]. The
empty set, vector and partition are all denoted by ∅.
Tree Decompositions and Treewidth. A tree decomposition [22] of a graph G
is a tree T in which each node x has an assigned set of vertices B
x
⊆ V (called
a bag) such that
x∈T
B
x
= V with the following properties: (i) for any uv ∈ E,
there exists an x ∈ T such that u, v ∈ B
x
, (ii) if v ∈ B
x
and v ∈ B
y
,thenv ∈ B
z
for all z on the (unique) path from x to y in T.Inanice tree decomposition, T
is rooted, and each bag is of one of the following types:
–LeafBag:aleafx of T with B
x
= ∅.
– Introduce Vertex Bag: an internal vertex x of T with one child vertex y
for which B
x
= B
y
∪{v} for some v/∈ B
y
.
– Introduce Edge Bag: an internal vertex x of T labeled with an edge uv ∈ E
with one child bag y for which u, v ∈ B
x
= B
y
.
– Forget Bag: an internal vertex x of T with one child bag y for which
B
x
= B
y
\{v} for some v ∈ B
y
.
–JoinBag:an internal vertex x with two child vertices l and r with B
x
=
B
r
= B
l
.
We require that every edge in E is introduced exactly once. This variant of nice
tree decompositions was also used by Cygan et al. [8].
A nice tree decomposition is a nice path decomposition if it does not contain
join bags. The width tw(T) of a (nice) tree decomposition T is the size of the
largest bag of T minus one, and the treewidth (pathwidth) of a graph G can be
defined as the minimum treewidth over all nice tree decompositions (nice path
decompositions) of G.
In this paper, we will always assume that nice tree decompositions of the
appropriate width are given. To each bag x in a nice tree decomposition T,we
associate the graph G
x
=(V
x
,E
x
) with V
x
the union of all bags B
y
with y a
descendant of x,andE
x
the set of all edges introduced in an descendant of x.
Further Notation. For two integers a, b we use a ≡ b to indicate that a is
even if and only if b is even. We use N to denote the set of all non-negative
integers. We use Iverson’s bracket notation: if p is a predicate we let [p]be1
if p is true and 0 otherwise. If ω : U →{1,...,N}, we shorthand ω(S)=
e∈S
ω(e)forS ⊆ U. For a function/vector s by s[v → α]wedenotethe
function s \{(v, s(v))}∪{(v, α)}. Note that this definition works regardless of
whether s(v) is already defined or not. We use either s|
X
or s
|X
to denote the
function obtained by restricting the domain to X.
200 H.L. Bodlaender et al.
3 The Rank Based Approac h
3.1 Main Ideas of the Approach
Recall that a dynamic programming algorithm fixes a way to decompose cer-
tificates into ‘partial certificates’, and builds partial certificates in a bottom-
up manner while storing only their essential information. Given some language
L ⊆{0, 1}
∗
, this is typically implemented by defining an equivalence ∼ on par-
tial certificates x, y ∈{0, 1}
k
such that x ∼ y if xz ∈ L ↔ yz ∈ L, for every
extension z ∈{0, 1}
l
. For connectivity problems on treewidth, the number of
non-equivalent certificates can be seen to be 2
Θ(tw·lg tw)
. See for example [21] for
a lower bound in communication complexity.
We will use however, that sometimes we can represent the joint essential
information for sets of partial certificates more efficiently than naively repre-
senting essential information for every partial certificate separately. The rank
based approach achieves this as follows: Given a dynamic programming algo-
rithm, consider the matrix A whose rows and columns are indexed by partial
certificates, with A[x, y] = 1 if and only if xy ∈ L. Then observe that if a set of
rows X ⊆{0, 1}
n
is linearly dependent (modulo 2), any partial certificate x ∈ X
is redundant in the sense that if xz ∈ L, there will be y ∈ X, y = x with yz ∈ L.
Hence, the essential information can be reduced to rk(A) partial certificates.
The second ingredient to our approach are proofs that for the considered
problems, the rank (working in GF(2)) of such a matrix A is single exponential
in the treewidth, and moreover, we can give explicit bases.
Now, the approach is as follows: take the ‘usual’ dynamic programming algo-
rithm for the problem at hand, but add the following step: after each compu-
tation of a table at a bag node, form the submatrix of A with for each entry
in the table a row and for each element of the basis a column; find a row-basis
of this matrix and continue with only the partial certificates in this basis, of
which there are not more than the rank of the certificate matrix. This is easily
extended to weighted problems using a minimum weighted row-basis. For getting
this approach to work for connectivity problems we require an upper bound on
the rank of the matrix M defined as follows: Fix a ground set U and let p and q
be partitions of U (p and q represent connectivity induced by partial solutions),
define M[p, q] to be 1 if and only if the meet of p and q is the trivial parti-
tion, that is, if the union of the partial solutions induce a connected solution.
Although this matrix has dimensions of order 2
θ(|U| log |U|)
, we exploit a simple
factorization in GF(2) of matrices with inner dimension 2
|U|
using an idea of [8].
To avoid creating a series of ad hoc results for single problems, we introduce a
collection of operations on sets of weighted partitions, such that our results ap-
ply to any dynamic programming (DP) formulation that can be expressed using
these operators only (see Section 3.2). In this extended abstract, we only state
and illustrate the main building blocks of the approach.
![Table 1. Our results for some famous computational problems. The second column gives running times when a path decomposition of width pw is given in the input; the third column gives running times when a tree decomposition of width tw is given in the input. Rows 1–4 use the rank-based approach; Rows 5–7 the determinant approach. ω denotes the matrix multiplication exponent (currently it is known that ω < 2.3727 [24]).](/figures/table-1-our-results-for-some-famous-computational-problems-4ubcfnco.webp)