Dynamic Programming and Fast Matrix

Multiplication

Frederic Dorn?

Department of Informatics, University of Bergen, PO Box 7800, 5020 Bergen, Norway

Abstract. We give a novel general approach for solving NP-hard opti-

mization problems that combines dynamic programming and fast matrix
multiplication. The technique is based on reducing much of the compu-
tation involved to matrix multiplication. We show that our approach
works faster than the usual dynamic programming solution for any ver-
tex subset problem on graphs of bounded branchwidth. In particular, we
obtain √the fastest algorithms for Planar Independent Set of runtime √
O(22.52 n ), for Planar Dominating
√
Set of runtime exact O(23.99 n )
and parameterized O(211.98 √
k
) · nO(1) , and for Planar Hamiltonian
5.58 n
Cycle of runtime O(2 ). The exponent of the running time is de-
pending heavily on the running time of the fastest matrix multiplication
algorithm that is currently o(n2.376 ).

1 Introduction
Dynamic programming is a useful tool for the fastest algorithms solving NP-hard
problems. We give a new technique for combining dynamic programming and
matrix multiplication and apply this approach to problems like Dominating
Set and Independent Set for improving the best algorithms on graphs of
bounded treewidth.
Fast matrix multiplication gives the currently fastest algorithms for some of
the most fundamental graph problems. The main algorithmic tool for solving the
All Pair Shortest Paths problem for both directed and undirected graphs
with small and large integer weights is to iteratively apply the distance product
on the adjacency matrix of a graph [18],[20],[3],[25]. Next to the distance product,
another variation of matrix multiplication—the boolean matrix multiplication—
is solved via fast matrix multiplication. Boolean matrix multiplication is used to
obtain the fastest algorithm for Recognizing Triangle-Free Graphs [16].
Recently,Vassilevska and Williams [23] applied the distance product to present
the first truly sub-cubic algorithm for finding a Maximum Node-Weighted
Triangle in directed and undirected graphs.
The fastest known matrix multiplication of two n × n-matrices by Copper-
smith and Winograd [6] in time O(nω ) for ω < 2.376 is also used for the fastest
boolean matrix multiplication in same time. Rectangular matrix multiplication
of an (n × p)- and (p × n)-matrix with p < n gives the runtime O(n1.85 · p0.54 ). If
?
Email:[email protected]. Supported by the Research Council of Norway.
p > n , we get time O(p · nω−1 ). The time complexity of the current algorithm
for distance product is O(n3 / log n), but for integer entries less than m, where
m is some small number, there is an O(mne ω
) algorithm [25]. For the arbitrarily
weighted distance product no truly sub-cubic algorithm is known. Though, [23]
show that the most significant bit of the distance product can be computed in
sub-cubic time, and they conjecture that their method may be extended in order
to compute the distance product.
Numerous problems are solved by matrix multiplication. However, for NP-
hard problems the common approaches do not involve fast matrix multiplication.
Williams [24] established new connections between fast matrix multiplication
and hard problems. He reduces the instances of the well-known problems Max-
2-SAT and Max-Cut to exponential size graphs dependent on some parameter
k, arguing that the optimum weight k-clique corresponds to an optimum solution
to the original problem instance.
The idea of applying fast matrix multiplication is basically to use the infor-
mation stored in the adjacency matrix of a graph in order to fast detect special
subgraphs such as shortest paths, small cliques—as in the previous example—
or fixed sized induced subgraphs. Uncommonly—as in [24]—we do not use the
technique on the graph directly. Instead, it facilitates a fast search in the solu-
tion space. In the literature, there has been some approaches speeding up linear
programming using fast matrix multiplication, e.g. see [22]. For our problems,
we consider dynamic programming, which is a method for reducing the runtime
of algorithms exhibiting the properties of overlapping subproblems and optimal
substructure. A standard approach for getting fast exact algorithms for NP-hard
problems is to apply dynamic programming across subsets of the solution space.
We present a novel approach to fast computing these subsets by applying the
distance product on the structure of dynamic programming.
Many NP-complete graph problems turn out to be solvable in polynomial
time or even linear time when restricted to the class of graphs of bounded
treewidth. The tree decomposition detects how “tree-like” a graph is and the
graph parameter treewidth is a measure of this “tree-likeness”. The correspond-
ing algorithms typically rely on a dynamic programming strategy. Telle and
Proskurowski [21] gave an algorithm based on tree decompositions having width `
that computes the Dominating Set of a graph in time O(9` ) · nO(1) . Alber et
al. [1] not only improved this bound to O(4` ) · nO(1) by using several tricks,
but also were the first to give a subexponential fixed parameter algorithm for
Planar Dominating Set.
Recently there have been several papers [11, 4, 8, 12, 13], showing that for
planar graphs or graphs of bounded genus the base of the exponent in the
running time of these algorithms could be improved by instead doing dynamic
programming along a branch decomposition of optimal branchwidth—both no-
tions are closely related to tree decomposition and treewidth. Fomin and Thi-
likos [11] significantly
√
improved the result of [1] for Planar Dominating Set
15.13 k 3
to O(2 k + n ) where k is the size of the solution. The same authors [13]
achieve small constants in the running time of a branch decomposition based ex-
act algorithms for
√ Planar Independent
√ Set and Planar Dominating Set,
namely O(23.182 n ) and O(25.043 n ), respectively. Dorn et al. [8] use the planar
structure of sphere cut decompositions to obtain fast√ algorithms for problems
like Planar Hamiltonian Cycle in time O(26.903 n ). Dynamic programming
along either a branch decomposition or a tree decomposition of a graph both
share the property of traversing a tree bottom-up and combining tables of solu-
tions to problems on certain subgraphs that overlap in a bounded-size separator
of the original graph.
Our contribution. We introduce a new dynamic programming approach on
branch decompositions. Instead of using tables, it stores the solutions in matrices
that are computed via distance product. Since distance product is not known to
have a fast matrix multiplication in general, we only consider unweighted and
small integer weighted problems with weights of size O(m) = nO(1) .
Our approach is fully general. It runs faster than the usual dynamic program-
ming for any vertex subset problem on graphs of bounded branchwidth. It also
can be used for tree decompositions with a structure proposed in [10]. To simplify
matters, we first introduce our technique on the Independent Set problem on
graphs of branchwidth bw and show the improvement from O(21.5 bw ) · nO(1) to
ω
O(2 2 bw ) · nO(1) where ω is the exponent of fast matrix multiplication (currently
ω < 2.376).
Next, we give the general technique and show how to apply it to several opti-
mization problems such as Dominating Set, that we improve from O(31.5 bw ) ·
nO(1) to O(4bw ) · nO(1) —please note that here ω influences the runtime indi-
rectly. Finally, we show the significant improvement of the low constants of the
runtime for the approach on planar graph problems. On Planar Dominating
Set we reduce the time to even O(20.793ω bw ) · nO(1)√
and hence an improvement
11.98 k
of the fixed parameter algorithm in [11] to O(2 ) · nO(1) where k is the size
of the dominating set. For exact subexponential algorithms as on Planar In-
dependent√ Set and Planar √ Dominating Set, this means an improvement
to O(21.06ω n ) and O(21.679ω n ), respectively. We also achieve an improvement
for several variants in [2] and [10].
Since the treewidth tw and branchwidth bw of a graph satisfy the relation
bw ≤ tw +1 ≤ 32 bw, it is natural to formulate the following question as done
in [10]: Given a tree decomposition and a branch decomposition, for which graphs
is it better to use a tree decomposition based approach and for which is branch
decomposition the appropriate tool? Table 1 compares our results to [10]. It
illustrates that dynamic programming is almost always faster on branch de-
compositions when using fast matrix multiplication rather than dynamic pro-
gramming on tree decompositions. For Planar Dominating Set it turns out
that our approach is always the better one in comparison to [1], i.e., we achieve
O(3.688bw ) < O(4tw ). For Planar Hamiltonian Cycle, we preprocess the
matrices in order
√ to apply our method using boolean matrix multiplication in
time O(22.347ω n ). In Table 1, we also add the runtimes for solving related prob-
lems and the runtime improvement compared to [8], [9], and [11], and [13].
Table 1. Worst-case runtime in the upper part expressed also by treewidth tw and
branchwidth bw of the input graph. The problems marked with ‘∗ ’ are the only one
where treewidth may be the better choice for some cutpoint tw ≤ α · bw with α = 1.19
and 1.05 (compare with [10]). The lower part gives a summary of the most important
improvements on exact and parameterized algorithms with parameter k. Note that we
use the fast matrix multiplication constant ω < 2.376.

Previous results New results

Dominating Set O(n2min{2 tw,2.38 bw} ) O(n22 bw )
Independent Set∗ O(n2tw ) O(n2min{tw,1.19 bw} )
min{2 tw,2.38 bw}
Independent Dominating Set O(n2 ) O(n22 bw )
Perfect Code∗ O(n2min{2 tw,2.58 bw} ) O(n2min{2 tw,2.09 bw} )
Perfect Dominating Set∗ O(n2min{2 tw,2.58 bw} ) O(n2min{2 tw,2.09 bw} )
Maximum 2-Packing∗ O(n2min{2 tw,2.58 bw} ) O(n2min{2 tw,2.09 bw} )
Total Dominating Set O(n2min{2.58 tw,3 bw} ) O(n22.58 bw )
Perfect Total Dom Set O(n2min{2.58 tw,3.16 bw} ) O(n22.58 bw )
√ √
Planar Dominating Set O(25.04√n ) O(23.99√n )
Planar Independent Set O(23.18√ n ) O(22.52√n )
Planar Hamiltonian Cycle O(26.9√n ) O(25.58 √n )
Planar Graph TSP O(29.86√n ) O(28.15√ n )
Planar connected Dom Set O(29.82√n ) O(28.11√n )
Planar Steiner Tree O(28.49√n ) O(27.16 √n )
Planar Feedback Vertex Set O(29.26 n ) O(27.56 n )
√ √
Parameterized Planar Dom Set O(215.13√ k k + n3 ) O(211.98√ k k + n3 )
Param Planar Longest Cycle O(213.6 k k + n3 ) O(210.5 k k + n3 )

2 Definitions
Branch decompositions. A branch decomposition hT, µi of a graph G is a
ternary tree T with a bijection µ from E(G) to the leaf-set L(T ). For every e ∈
E(T ) define middle set mid(e) ⊆ V (G) as follows: For every two leaves `1 , `2 with
vertex v adjacent to both µ−1 (`1 ) and µ−1 (`2 ), we have that v ∈ mid(e) for all
edges e along the path from `1 to `2 . The width bw of hT, µi is the maximum order
of the middle sets over all edges of T , i.e., bw(hT, µi) := max{| mid(e)| : e ∈ T }.
An optimal branch decomposition of G is defined by the tree T and the bijection
µ which together provide the minimum width, the branchwidth bw(G).
Dynamic programming. For a graph G with |V (G)| = n of bounded branch-
width bw the weighted Independent Set problem with positive node weights
wv for all v ∈ V (G) can be solved in time O(f (bw)) · nO(1) where f (·) is an expo-
nential time function only dependent on bw. The algorithm is based on dynamic
programming on a rooted branch decomposition hT, µi of G. The independent
set is computed by processing T in post-order from the leaves to the root. For
each middle set mid(e) an optimal independent set intersects with some subset
U of mid(e). Since mid(e) may have size up to bw, this may give 2bw possible
subsets to consider. The separation property of mid(e) ensures that the problems
in the different subtrees can be solved independently.
 We root T by arbitrarily choosing an edge e, and subdivide it by inserting
a new node s. Let e0 , e00 be the new edges and set mid(e0 ) = mid(e00 ) = mid(e).
Create a new node root r, connect it to s and set mid({r, s}) = ∅. Each internal
node v of T now has one adjacent edge on the path from v to r, called the parent
edge, and two adjacent edges towards the leaves, called the children edges. To
simplify matters, we call them the left child and the right child.
Let Te be a subtree of T rooted at edge e. Ge is the subgraph of G induced
by all leaves of Te . For a subsetPU of V (G) let w(U ) denote the total weight of
nodes in U . That is, w(U ) = u∈U wu . Define a set of subproblems for each
subtree Te . Each set corresponds to a subset U ⊆ mid(e) that may represent the
intersection of an optimal solution with V (Ge ). Thus, for each independent set
U ⊆ mid(e), we denote by Ve (U ) the maximum weight of an independent set S
in Ge such that S ∩ mid(e) = U , that is w(S) = Ve (U ). We set Ve (U ) = −∞
if U is not an independent set since U cannot be part of an optimal solution.
There are 2| mid(e)| possible subproblems associated with each edge e of T . Since
T has O(|E(G)|) edges, there are in total at most 2bw · |E(G)| subproblems. The
maximum weight independent set is determined by taking the maximum over
all subproblems associated with the root r.
For each edge e the information needed to compute Ve (U ) is already com-
puted in the values for the subtrees. Since T is ternary, we have that a parent
edge e has two children edges f and g. For f and g, we simply need to determine
the value of the maximum-weight independent sets Sf of Gf and Sg of Gg , sub-
ject to the constraints that Sf ∩ mid(e) = U ∩ mid(f ), Sg ∩ mid(e) = U ∩ mid(g)
and Sf ∩ mid(g) = Sg ∩ mid(f ).
With independent sets Uf ⊆ mid(f ) and Ug ⊆ mid(g) that are not necessarily
optimal, the value Ve (U ) is given as follows:

Ve (U ) = w(U ) + max{Vf (Uf ) − w(Uf ∩ U ) + Vg (Ug ) − w(Ug ∩ U )

− w(Uf ∩ Ug \ U )} s.t. Uf ∩ mid(e) = U ∩ mid(f ),
Ug ∩ mid(e) = U ∩ mid(g), and Uf ∩ mid(g) = Ug ∩ mid(f ). (1)

The brute force approach computes for all 2| mid(e)| sets U associated with e
the value Ve (U ) in time O(2| mid(f )| · 2| mid(g)| ). Hence, the total time spent on
edge e is O(8bw ).
Matrix multiplication. Two (n × n)-matrices can be multiplied using O(nω )
algebraic operations, where the naive matrix multiplication shows ω ≤ 3. The
best upper bound on ω is currently ω < 2.376 [6].
For rectangular matrix multiplication between two (n × p)- and (p × n)-
matrices B = (bij ) and C = (cij ) we differentiate between p ≤ n and p > n. For
the case p ≤ n Coppersmith [5] gives an O(n1.85 · p0.54 ) time algorithm (under
the assumption that ω = 2.376). If p > n , we get O( np · n2.376 + np · n2 ) by
matrix splitting: Split each matrix into np many n × n matrices B1 , . . . , B np and
C1 , . . . , C np and multiply each A` = B` · C` (for all 1 ≤ ` ≤ np ). Sum up each
entry a`ij overall matrices A` to obtain the solution.
 The distance product of two (n × n)-matrices B and C, denoted by B ? C, is
an (n × n)-matrix A such that

aij = min {bik + ckj }, 1 ≤ i, j ≤ n. (2)

1≤k≤n

The distance product of two (n × n)-matrices can be computed naively in time

O(n3 ). Zwick [25] describes a way of using fast matrix multiplication, and fast
integer multiplication, to compute distance products of matrices whose elements
are taken from the set {−m, . . . , 0, . . . , m} The running time of the algorithm is
e · nω ). For distance product of two (n × p)- and (p × n)-matrices with p > n
O(m
e · (m · nω−1 )) again by matrix splitting: Here we take the minimum
we get O(p
of the entries a`ij overall matrices A` with 1 ≤ ` ≤ np .

3 Dynamic programming & distance product

In this section, we will continue our Independent Set example and oppose
two techniques on how to obtain faster dynamic programming approaches. The
previous algorithms use tables in order to decrease the number of times a subset
is queried. As a second approach, we introduce a technique using matrices that
allows to highly make use of the structure of branch decompositions and of the
fast matrix multiplication.
Tables. We will see now a more sophisticated approach that exploits properties
of the middle sets and uses tables as data structure. With a table, one has an
object that allows to store all sets U ⊆ mid(e) in an ordering such that the time
used per edge is reduced to O(21.5 bw ).
By the definition of middle sets, a vertex has to be in at least two of three
middle sets of adjacent edges e, f, g. You may simply recall that a vertex has to
be in all middle sets along the path between two leaves of T .
For the sake of a refined analysis, we partition the middle sets of parent
edge e and left child f and right child g into four sets L, R, F, I as follows:
• Intersection I := mid(e) ∩ mid(f ) ∩ mid(g),
• Forget F := mid(f ) ∩ mid(g) \ I,
• Symmetric difference L := mid(e) ∩ mid(f ) \ I and R := mid(e) ∩ mid(g) \ I.
We thus can restate the constraints of (1) for the computation of value Ve (U ).
Weight w(U ) is already contained in w(Uf ∪Ug ) since mid(e) ⊆ mid(f )∪mid(g).
Hence, we can change the objective function:

Ve (U ) = max{Vf (Uf ) + Vg (Ug ) − w(Uf ∩ Ug )}

s.t. Uf ∩ (I ∪ L) = U ∩ (I ∪ L), Ug ∩ (I ∪ R) = U ∩ (I ∪ R),
and Uf ∩ (I ∪ F ) = Ug ∩ (I ∪ F ). (3)

Turning to tables, each edge e is assigned a table T ablee that is labeled with
the sequence of vertices mid(e). More precisely, the table is labeled with the
concatenation of three sequences out of {L, R, I, F }. Define the concatenation
’k’ of two sequences λ1 and λ2 as λ1 kλ2 . Then, concerning parent edge e and left
child f and right child g we obtain the labels: ’IkLkR’ for T ablee, ’IkLkF ’ for
T ablef , and ’IkRkF ’ for T ableg . T ablef contains all sets Uf with value Vf (Uf )
and analogously, T ableg contains all sets Ug with value Vg (Ug ).
For computing Ve (U ) of each of the 2|I|+|L|+|R| entries of T ablee, we thus
only have to consider 2|F | sets Uf and Ug subject to the constraints in (3). Since
mid(e)∪mid(f )∪mid(g) = I ∪L∪R∪F , we have that |I|+|L|+|R|+|F | ≤ 1.5·bw.
Thus we spend in total time O(21.5 bw ) on each edge of T .
A technical note: for achieving an efficient running time, one uses an adequate
encoding of the table entries. First define a coloring c : V (G) → {0, 1}: For an
edge e, each set U ⊆ mid(e), if v ∈ mid(e) \ U then c(v) = 0 else c(v) = 1. Then
sort T ablef and T ableg to get entries in an increasing order in order to achieve
a fast inquiry.
Matrices. In the remaining section we show how to use matrices instead of
tables as data structure for dynamic programming. Then we apply the distance
product of two matrices to compute the values V(U ). With U ∩ I = Uf ∩ I =
Ug ∩ I, one may observe that every independent set Se of Ge is determined
by the independent sets Sf and Sg such that all three sets intersect in some
subset U I ⊆ I. The idea is to not compute Ve (U ) for every subset U separately
but to simultaneously calculate for each subset U I ⊆ I the values Ve (U ) for all
U ⊆ mid(e) subject to the constraint that U ∩ I = U I . For each of these sets
U the values Ve (U ) are stored in a matrix A. A row is labeled with a subset
U L ⊆ L and a column with a subset U R ⊆ R. The entry determined by row U L
and column U R is filled with Ve (U ) for U subject to the constraints U ∩ L = U L ,
U ∩ R = U R , and U ∩ I = U I .
We will show how matrix A is computed by the distance product of the two
matrices B and C assigned to the children edges f and g: For the left child f , a
row of matrix B is labeled with U L ⊆ L and a column with U F ⊆ F that appoint
the entry Vf (Uf ) for Uf subject to the constraints Uf ∩ L = U L , Uf ∩ F = U F
and Uf ∩ I = U I . Analogously we fill the matrix C for the right child with
values for all independent sets Ug with Ug ∩ I = U I . Now we label a row with
U F ⊆ F and a column with U R ⊆ R storing value Vg (Ug ) for Ug subject to the
constraints Ug ∩ F = U F and Ug ∩ R = U R . Note that entries have value ‘−∞’
if they are determined by two subsets where at least one set is not independent.

Lemma 1. Given an independent set U I ⊆ I. For all independent sets U ⊆

mid(e), Uf ⊆ mid(f ) and Ug ⊆ mid(g) subject to the constraint U ∩I = Uf ∩I =
Ug ∩ I = U I let the matrices B and C have entries Vf (Uf ) and Vg (Ug ). The
entries Ve (U ) of matrix A are computed by the distance product A = B ? C.

Proof. The rows and columns of A, B and C must be ordered that two equal
subsets stand at the same position, i.e., U L must be at the same position in either
row of A and B, U R in either column of A and C, and U F must be in the same
position in the columns of B as in the rows of C. In order to apply the distance
product of (2), we change the signs of each entry in B and C since we deal
with a maximization rather than a minimization problem. Another difference
between (2) and (3) is the additional term w(Uf ∩ Ug ). Since Uf and Ug only
intersect in U I and U F , we substitute entry Vg (Ug ) in C for Vg (Ug )−|U I |−|U F |
and we get a new equation:

Ve (U ) = min{−Vf (Uf ) − (Vg (Ug ) − |U I | − |U F |)}

s.t. U ∩ I = Uf ∩ I = Ug ∩ I = U I , Uf ∩ L = U ∩ L = U L ,
and Ug ∩ R = U ∩ R = U R , and Uf ∩ F = Ug ∩ F = U F }. (4)

Since we have for the worst case analysis that |L| = |R| due to symmetry reason,
we may assume that |U L | = |U R | and thus A is a square matrix. Every value
Ve (U ) in matrix A can be calculated by the distance product of matrix B and C,
i.e., by taking the minimum over all sums of entries in row U L in B and column
U R in C.

Theorem 1. Dynamic programming for the Independent Set problem on

e
weights O(m) = nO(1) on graphs of branchwidth bw takes time O(m
ω
· 2 2 ·bw )
with ω the exponent of the fastest matrix multiplication.

Proof. For every U I we compute the distance product of B and C with absolute
integer values less than m. We show that, instead of a O(2|L|+|R|+|F |+|I|) running
time, dynamic programming takes time O(m e · 2(ω−1)|L| · 2|F | · 2|I|). We need time
O(2 ) for considering all subsets U ⊆ I. Under the assumption that 2|F | ≥ 2|L|
|I| I

we get the running time for rectangular matrix multiplication: O(m e · 2|F |
· 2ω|L| ).
2|L|
If 2|F | < 2|L| we simply get O(me · 21.85|L| · 20.54|F | ) (for ω = 2.376), so basically
the same running time behavior. By the definition of the sets L, R, I, F we obtain
four constraints:
• |I| + |L| + |R| ≤ bw, since mid(e) = I ∪ L ∪ R,
• |I| + |L| + |F | ≤ bw, since mid(f ) = I ∪ L ∪ F ,
• |I| + |R| + |F | ≤ bw, since mid(g) = I ∪ R ∪ F , and
• |I| + |L| + |R| + |F | ≤ 1.5 · bw, since mid(e) ∪ mid(f ) ∪ mid(g) = I ∪ L ∪ R ∪ F .
When we maximize our objective function O(m e · 2(ω−1)|L| · 2|F | · 2|I| ) subject
ω
to these constraints, we get the claimed running time of O(m e · 2 2 ·bw ).

4 A general technique
In this section we formulate the dynamic programming approach using distance
product in a more general way than in the previous section in order to apply it to
several optimization problems. In the literature these problems are often called
vertex-state problems. That is, we have given an alphabet λ of vertex-states de-
fined by the corresponding problem. E.g., for the considered Independent Set
we have that the vertices in the graph have two states relating to an independent
set U : state ‘1’ means “element of U ” and state ‘0’ means “not an element of
U ”. We define a coloring c : V (G) → λ and assign for an edge e of the branch
decomposition hT, µi a color c to each vertex in mid(e). Given an ordering of
mid(e), a sequence of vertex-states forms a string Se ∈ λ| mid(e)| . For a further
details, please consult for example [10].
 Recall the definition of concatenating two strings S1 and S2 as S1 kS2 . We
then define the strings Sx (ρ) with ρ ∈ {L, R, F, I} of length |ρ| as substrings of Sx
with x ∈ {e, f, g} with e parent edge, f left child and g right child. We set Se =
Se (I)kSe (L)kSe (R), Sf = Sf (I)kSf (L)kSf (F ) and Sg = Sg (I)kSg (F )kSg (R).
We say Se is formed by the strings Sf and Sg if Se (ρ), Sf (ρ) and Sg (ρ) suffice
some problem dependent constraints for some ρ ∈ {L, R, F, I}. For Indepen-
dent Set we had in the previous section that Se is formed by the strings
Sf and Sg if Se (I) = Sf (I) = Sg (I), Se (L) = Sf (L), Se (R) = Sg (R) and
Sf (F ) = Sg (F ). For problems as Dominating Set it is sufficient to mention
that “formed” is differently defined, see for example [10]. With the common dy-
|L| |R| |F | |I|
namic programming approach of using tables, we get to proceed c1 ·c1 ·c2 ·c3
update operations of polynomial time where c1 , c2 and c3 are small problem de-
pendent constants. Actually, we consider |λ||L| · |λ||F | · |λ||I| solutions of Gf and
|λ||R| · |λ||F | · |λ||I| solutions of Gg to obtain |λ||L| · |λ||R| · |λ||I| solutions of Ge .
In every considered problem, we have c1 ≡ |λ|, c2 , c3 ≤ |λ|2 and c1 ≤ c2 , c3 .
We construct the matrices as follows: For the edges f and g we fix a string
Sf (I) ∈ λI and a string Sg (I) ∈ λI such that Sf (I) and Sg (I) form a string
Se (I) ∈ λI . Recall the definition of value Ve as the maximum (minimum) weight
|L| |R|
of a solution class. We compute a matrix A with c1 rows and c1 columns
and with entries Ve (Se ) for all strings Se that contain Se (I). That is, we la-
bel monotonically increasing both the rows with strings Se (L) and the columns
with strings Se (R) that determine the entry Ve (Se ) subject to the constraint
Se = Se (I)kSe (L)kSe (R).
Using the distance product, we compute matrix A from matrices B and
C that are assigned to the child edges f and g, respectively. Matrix B is la-
beled monotonically increasing row-wise with strings Sf (L) and column-wise
|L| |F |
with strings Sf (F ). That is, B has c1 rows and c2 columns. A column la-
beled with string Sf (F ) is duplicated depending on how often it contributes
to forming the strings Se ⊃ Se (I). The entry determined by Sf (L) and Sf (F )
consists of the value Vf (Sf ) subject to Sf = Sf (I)kSf (L)kSf (F ). Analogously,
|F | |R|
we compute for edge g the matrix C with c2 rows and c1 columns and with
entries Vg (Sg ) for all strings Sg that contain Sg (I). We label the columns with
strings Sg (R) and rows with strings Sg (F ) with duplicates as for matrix B.
However, we do not sort the rows by increasing labels. We order the rows such
that the strings Sg (F ) and Sf (F ) match, where Sg (F ) is assigned to row k
in C and Sf (F ) is assigned to column k in B. I.e., for all Sf (L) and Sg (R)
we have that Sf = Sf (I)kSf (L)kSf (F ) and Sg = Sg (I)kSg (F )kSg (R) form
Se = Se (I)kSe (L)kSe (R). The entry determined by Sg (F ) and Sg (R) consists
of the value Vg (Sg ) subject to Sg = Sg (I)kSg (F )kSg (R) minus an overlap. The
overlap is the contribution of the vertex-states of the vertices of Sg (F ) ∩ F
and Sg (I) ∩ I to Vg (Sg ). That is, the part of the value that is contributed by
Sg (F )kSg (R) is not counted since it is already counted in Vf (Sf ).

Lemma 2. Consider fixed strings Se (I), Sf (I) and Sg (I) such that there exist
solutions Se ⊃ Se (I) formed by some Sf ⊃ Sf (I) and Sg ⊃ Sg (I). The values
Vf (Sf ) and Vg (Sg ) are stored in matrices B and C, respectively. Then the values
Ve (Se ) of all possible solutions Se ⊃ Se (I) are computed by the distance product
of B and C, and are stored in matrix A = B ? C.

The following theorem refers to all the problems enumerated in Table 1.

Theorem 2. Let ω be the exponent of the fastest matrix multiplication and

c1 , c2 and c3 the number of algebraic update operations for the sets {L, R},
F and I, respectively. Then, dynamic programming for solving vertex-state prob-
lems on weights O(m) = nO(1) on graphs of branchwidth bw takes time O(m e ·
(ω−1)· bw bw
max{c1 2
c22 , cbw bw
2 , c3 }).

5 Application of the new technique

In this section, we show how one can apply the technique for several optimiza-
tion problems such as Dominating Set and its variants in order to obtain fast
algorithms. We also apply our technique to planar √ graph problems. The branch-
width of a planar graph is bounded by 2.122 n. There exist optimal branch
decompositions whose middle sets are closed Jordan curves in the planar graph
embedding [8]. Such a sphere cut decomposition has the property that the I-set
is of size at most 2, that is, the runtime stated in Theorem 2 has no part ’cbw 3 ’.
For Dominating Set we have that c1 ≡ c2 = 3 and c3 = 4. The former run-
ning time was O(31.5 bw ) · nO(1) . We have O(me · max{3(ω−1)· bw bw
2 3 2 , 3bw , 4bw }) =

e
O(m · 4bw ) for node weights O(m) if we use a matrix multiplication algorithm
with ω < 2.5 and thus hide the factor ω.
Sphere cut decompositions of planar graphs can be computed in time O(n3 )
by an improvement of the famous rat catcher method ([19] and [14]). With the
nice property that |I| ≤ 2 for all middle sets, we achieve a running time in
e (ω−1)· bw bw
terms of O(m · max{c1 2
c22 , cbw
2 }) for planar graph problems. Thus, we
improve for Planar Dominating Set with node weights O(m) the runtime
e
O(4bw )·nO(1) to O(m·3 1.188 bw e
) = O(m·3.688 bw
). This runtime is strictly better
than the actual runtime of the treewidth based technique of O(4tw ) · nO(1) .
For Planar Hamiltonian Cycle, it is not immediately clear how to use
matrices since here it seems necessary to compute the entire solution at a dy-
namic programming step. I.e., in [8] the usual dynamic programming step is
applied with the difference that a postprocessing step uncovers forbidden so-
lutions and changes the coloring of the vertices in the L- and R-set. The idea
that helps is that we replace the latter step by a preprocessing step, changing
the matrix entries of the child edges depending on the change of the coloring.
That coloring is only dependent on the coloring of the F -set in both matrices.
Hence we do not query the coloring of all three sets L, R and F simultaneously.
This means that this step does not increase the runtime of our algorithm that
is improved to O(me · 21.106ω bw ) by applying boolean matrix multiplication.
6 Conclusions
We established a combination of dynamic programming and fast matrix mul-
tiplication as an important tool for finding fast exact algorithms for NP-hard
problems. Even though the currently best constant ω < 2.376 of fast matrix
multiplication is of rather theoretical interest, there exist indeed some practi-
cal sub-cubic runtime algorithms that help improving the runtime for solving
all mentioned problems. An interesting side-effect of our technique is that any
improvement on the constant ω has a direct effect on the runtime behavior for
solving the considered problems. E.g., for Planar Dominating Set; under the
assumption that ω = 2, we come to the point where the constant in the compu-
tation is 3 what equals the number of vertex states, which is the natural lower
bound for dynamic programming. Currently, [23] have made some conjecture
on an improvement for distance product, which would enable us to apply our
approach to optimization problems with arbitrary weights. Is there anything
to win for dynamic programming if we use 3-dimensional matrices as a data
structure? That is, if we have the third dimension labeled with Se (I)?
Acknowledgments. Many thanks to Fedor Fomin for his useful comments and
his patience, Artem Pyatkin for some fruitful discussions, and an anonymous
referee for his comments, and Charis Papadopoulos, and Laura Toma.

References
1. J. Alber, H. L. Bodlaender, H. Fernau, T. Kloks, and R. Niedermeier,
Fixed parameter algorithms for dominating set and related problems on planar
graphs, Algorithmica, 33 (2002), pp. 461–493.
2. J. Alber and R. Niedermeier, Improved tree decomposition based algorithms
for domination-like problems, in LATIN’02: Theoretical informatics (Cancun),
vol. 2286 of Lecture Notes in Computer Science, Berlin, 2002, Springer, pp. 613–
627.
3. N. Alon, Z. Galil, and O. Margalit, On the exponent of the all pairs shortest
path problem, Journal of Computer and System Sciences, 54 (1997), pp. 255–262.
4. W. Cook and P. Seymour, Tour merging via branch-decomposition, INFORMS
Journal on Computing, 15 (2003), pp. 233–248.
5. D. Coppersmith, Rectangular matrix multiplication revisited, Journal of Com-
plexity, 13 (1997), pp. 42–49.
6. D. Coppersmith and S. Winograd, Matrix multiplication via arithmetic pro-
gressions, Journal of Symbolic Computation, 9 (1990), pp. 251–280.
7. T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein, Introduction
to Algorithms, Second Edition, The MIT Press and McGraw-Hill Book Company,
2001.
8. F. Dorn, E. Penninkx, H. Bodlaender, and F. V. Fomin, Efficient exact
algorithms on planar graphs: Exploiting sphere cut branch decompositions, in Pro-
ceedings of the 13th Annual European Symposium on Algorithms (ESA 2005),
vol. 3669 of LNCS, Springer, Berlin, 2005, pp. 95–106.
9. , Efficient exact algorithms on planar graphs: Exploiting sphere cut decom-
positions, 2006. manuscript, http://archive.cs.uu.nl/pub/RUU/CS/techreps/CS-
2006/2006-006.pdf.
10. F. Dorn and J. A. Telle, Two birds with one stone: the best of branchwidth
and treewidth with one algorithm, in LATIN’06: 7th Latin American Theoretical
Informatics Symposium (Valdivia), vol. 3887 of Lecture Notes in Computer Science,
Berlin, 2006, Springer, pp. 386–397.
11. F. V. Fomin and D. M. Thilikos, Dominating sets in planar graphs: branch-
width and exponential speed-up, in SODA’03: Proceedings of the Fourteenth Annual
ACM-SIAM Symposium on Discrete Algorithms (Baltimore, MD, 2003), New York,
2003, ACM, pp. 168–177.
12. F. V. Fomin and D. M. Thilikos, Fast parameterized algorithms for graphs on
surfaces: Linear kernel and exponential speed-up, in Proceedings of the 31st Inter-
national Colloquium on Automata, Languages and Programming (ICALP 2004),
vol. 3142 of LNCS, Berlin, 2004, Springer, pp. 581–592.
13. , A simple and fast approach for solving problems on planar graphs, in Pro-
ceedings of the 21st International Symposium on Theoretical Aspects of Computer
Science (STACS 2004), vol. 2996 of LNCS, Springer, Berlin, 2004, pp. 56–67.
14. Q.-P. Gu and H. Tamaki, Optimal branch-decomposition of planar graphs in
O(n3 ) time, in Proceedings of the 32nd International Colloquium on Automata,
Languages and Programming (ICALP 2005), vol. 3580 of LNCS, Springer, Berlin,
2005, pp. 373–384.
15. P. Heggernes, J. A. Telle, and Y. Villanger, Computing minimal triangula-
tions in time O(nα logn) = o(n2.376 ), SIAM Journal on Discrete Mathematics, 19
(2005), pp. 900–913.
16. A. Itai and M. Rodeh, Finding a minimum circuit in a graph, SIAM Journal on
Computing, 7 (1978), pp. 413–423.
17. D. Kratsch and J. Spinrad, Between O(nm) and O(nα ), in SODA’03: Proceed-
ings of the Fourteenth Annual ACM-SIAM Symposium on Discrete Algorithms
(Baltimore, MD, 2003), New York, 2003, ACM, pp. 158–167.
18. R. Seidel, On the all-pairs-shortest-path problem in unweighted undirected graphs,
Journal of Computer and System Sciences, 51 (1995), pp. 400–403.
19. P. D. Seymour and R. Thomas, Call routing and the ratcatcher, Combinatorica,
14 (1994), pp. 217–241.
20. A. Shoshan and U. Zwick, All pairs shortest paths in undirected graphs with
integer weights, in 40th Annual Symposium on Foundations of Computer Science,
(FOCS ’99), Lecture Notes in Computer Science, Springer, 1999, pp. 605–615.
21. J. A. Telle and A. Proskurowski, Algorithms for vertex partitioning problems
on partial k-trees, SIAM J. Discrete Math, 10 (1997), pp. 529–550.
22. P. M. Vaidya, Speeding-up linear programming using fast matrix multiplication,
in 30th Annual Symposium on Foundations of Computer Science (FOCS 1989),
1989, pp. 332–337.
23. V. Vassilevska and R. Williams, Finding a maximum weight triangle in n(3−δ)
time, with applications, 2006. To appear in ACM Symposium on Theory of Com-
puting (STOC 2006), http://www.cs.cmu.edu/ ryanw/max-weight-triangle.pdf.
24. R. Williams, A new algorithm for optimal constraint satisfaction and its impli-
cations, in Proceedings of the 31st International Colloquium on Automata, Lan-
guages and Programming (ICALP 2004), vol. 3142 of LNCS, Springer, Berlin, 2004,
pp. 1227–1237.
25. U. Zwick, All pairs shortest paths using bridging sets and rectangular matrix mul-
tiplication, Journal of the ACM, 49 (2002), pp. 289–317.